diff --git a/MuseV/MMCM/.gitignore b/MuseV/MMCM/.gitignore new file mode 100755 index 0000000000000000000000000000000000000000..985b254ca41c080091b4de7455d9be21fd2c2f4f --- /dev/null +++ b/MuseV/MMCM/.gitignore @@ -0,0 +1,139 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don’t work, or not +# install all needed dependencies. +#Pipfile.lock + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +*.swp +.*.swp +dataset/files +experiments +log +csvs + +.idea +.vscode +__pycache__/ +*.code-workspace +.DS_Store +third_party/ +.polaris_cache/ +*.lock \ No newline at end of file diff --git a/MuseV/MMCM/Dockerfile b/MuseV/MMCM/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..960b7abf34e63ffe314aa419e4f47a36b951d1e8 --- /dev/null +++ b/MuseV/MMCM/Dockerfile @@ -0,0 +1,83 @@ +# FROM mirrors.tencent.com/todacc/venus-std-base-cuda11.8:0.1.0 +FROM mirrors.tencent.com/todacc/venus-std-ext-cuda11.8-pytorch2.0-tf2.12-py3.10:0.7.0 + +#MAINTAINER 维护者信息 +LABEL MAINTAINER="anchorxia" +LABEL Email="xzqjack@hotmail.com" +LABEL Description="gpu development image, from mirrors.tencent.com/todacc/venus-std-ext-cuda11.8-pytorch2.0-tf2.12-py3.10:0.7.0" + +USER root +# 安装必须软件 +# RUN GENERIC_REPO_URL="http://mirrors.tencent.com/repository/generic/venus_repo/image_res" \ +# && cd /data/ \ +# && wget -q $GENERIC_REPO_URL/gcc/gcc-11.2.0.zip \ +# && unzip -q gcc-11.2.0.zip \ +# && cd gcc-releases-gcc-11.2.0 \ +# && ./contrib/download_prerequisites \ +# && ./configure --enable-bootstrap --enable-languages=c,c++ --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib \ +# && make --silent -j10 \ +# && make --silent install \ +# && gcc -v \ +# && rm -rf /data/gcc-releases-gcc-11.2.0 /data/gcc-11.2.0.zip + +# RUN yum update -y \ +# && yum install -y epel-release \ +# && yum install -y ffmpeg \ +# && yum install -y Xvfb \ +# && yum install -y centos-release-scl devtoolset-11 +RUN yum install -y wget zsh git curl tmux cmake htop iotop git-lfs zip \ + && yum install -y autojump autojump-zsh portaudio portaudio-devel \ + && yum clean all + +USER mqq +RUN source ~/.bashrc \ + && GENERIC_REPO_URL="http://mirrors.tencent.com/repository/generic/venus_repo/image_res" \ + && conda deactivate \ + # && conda remove -y -n env-2.7.18 --all \ + # && conda remove -y -n env-3.6.8 --all \ + # && conda remove -y -n env-3.7.7 --all \ + # && conda remove -y -n env-3.8.8 --all \ + # && conda remove -y -n env-3.9.2 --all \ + # && conda remove -y -n env-novelai --all \ + && conda create -n projectv python=3.10.6 -y \ + && conda activate projectv \ + && pip install venus-sdk -q -i https://mirrors.tencent.com/repository/pypi/tencent_pypi/simple \ + --extra-index-url https://mirrors.tencent.com/pypi/simple/ \ + && pip install tensorflow==2.12.0 tensorboard==2.12.0 \ + && pip install torch==2.0.1+cu118 torchvision==0.15.2+cu118 -f https://mirror.sjtu.edu.cn/pytorch-wheels/torch_stable.html -i https://mirrors.bfsu.edu.cn/pypi/web/simple -U \ + # 安装xformers，支持不同型号gpu + && pip install ninja==1.11.1 \ + # && git clone https://github.com/facebookresearch/xformers.git \ + # && cd xformers \ + # && git checkout v0.0.17rc482 \ + # && git submodule update --init --recursive \ + # && pip install numpy==1.23.4 pyre-extensions==0.0.23 \ + # && FORCE_CUDA="1" MAX_JOBS=1 TORCH_CUDA_ARCH_LIST="6.1;7.0;7.5;8.0;8.6" pip install -e . \ + # && cd .. \ + # 安装一堆包 + && pip install --no-cache-dir transformers bitsandbytes decord accelerate xformers omegaconf einops imageio==2.31.1 \ + && pip install --no-cache-dir pandas h5py matplotlib modelcards pynvml black pytest moviepy torch-tb-profiler scikit-learn librosa ffmpeg easydict webp controlnet_aux mediapipe \ + && pip install --no-cache-dir Cython easydict gdown infomap insightface ipython librosa onnx onnxruntime onnxsim opencv_python Pillow protobuf pytube PyYAML \ + && pip install --no-cache-dir requests scipy six tqdm gradio albumentations opencv-contrib-python imageio-ffmpeg pytorch-lightning test-tube \ + && pip install --no-cache-dir timm addict yapf prettytable safetensors basicsr fvcore pycocotools wandb gunicorn \ + && pip install --no-cache-dir streamlit webdataset kornia open_clip_torch streamlit-drawable-canvas torchmetrics \ + # 安装暗水印 + && pip install --no-cache-dir invisible-watermark==0.1.5 gdown==4.5.3 ftfy==6.1.1 modelcards==0.1.6 \ + # 安装openmm相关包 + && pip install--no-cache-dir -U openmim \ + && mim install mmengine \ + && mim install "mmcv>=2.0.1" \ + && mim install "mmdet>=3.1.0" \ + && mim install "mmpose>=1.1.0" \ + # jupyters + && pip install ipywidgets==8.0.3 \ + && python -m ipykernel install --user --name projectv --display-name "python(projectv)" \ + && pip install --no-cache-dir matplotlib==3.6.2 redis==4.5.1 pydantic[dotenv]==1.10.2 loguru==0.6.0 IProgress==0.4 \ + && pip install --no-cache-dir cos-python-sdk-v5==1.9.22 coscmd==1.8.6.30 \ + # 必须放在最后pip，避免和jupyter的不兼容 + && pip install --no-cache-dir markupsafe==2.0.1 \ + && wget -P /tmp $GENERIC_REPO_URL/cpu/clean-layer.sh \ + && sh /tmp/clean-layer.sh + +ENV LD_LIBRARY_PATH=/usr/local/lib64:$LD_LIBRARY_PATH +USER root diff --git a/MuseV/MMCM/README.md b/MuseV/MMCM/README.md new file mode 100755 index 0000000000000000000000000000000000000000..37f5d4b7c9ee23ff01b4cd9391e0e0b5f00b70a5 --- /dev/null +++ b/MuseV/MMCM/README.md @@ -0,0 +1,2 @@ +# MMCM +Process package for multi media, cross multi modal. \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/__init__.py b/MuseV/MMCM/mmcm/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..83031643e94770cf5c0932170b5609808f0852e5 --- /dev/null +++ b/MuseV/MMCM/mmcm/__init__.py @@ -0,0 +1,6 @@ +from .audio import * +from .data import * +from .music import * +from .text import * +from .vision import * +from .t2p import * \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/audio/__init__.py b/MuseV/MMCM/mmcm/audio/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/data/__init__.py b/MuseV/MMCM/mmcm/data/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..0eb17fb22a06992d9e8279e0d52d1ffdc7e5904c --- /dev/null +++ b/MuseV/MMCM/mmcm/data/__init__.py @@ -0,0 +1,9 @@ +from .general.items import Items, Item + +from .emb.emb import MediaMapEmb +from .emb.h5py_emb import H5pyMediaMapEmb, H5pyMediaMapEmbProxy + +from .media_map.media_map import MediaMap, MetaInfo, MetaInfoList, MediaMapSeq +from .media_map.media_map_process import get_sub_mediamap_by_clip_idx, get_sub_mediamap_by_stage, get_subseq_by_time +from .clip.clip import Clip, ClipSeq +from .clip.clipid import ClipIds, ClipIdsSeq, MatchedClipIds, MatchedClipIdsSeq \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/clip.py b/MuseV/MMCM/mmcm/data/clip.py new file mode 100755 index 0000000000000000000000000000000000000000..5a57322155454e760a91ae9ca4c7a00646b64260 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip.py @@ -0,0 +1,324 @@ +from copy import deepcopy +from typing import Iterable +import logging + +import numpy as np + +from ..utils.util import convert_class_attr_to_dict + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class Clip(object, Item): + """媒体片段, 指转场点与转场点之间的部分""" + + def __init__( + self, + time_start, + duration, + clipid=None, + media_type=None, + mediaid=None, + timepoint_type=None, + text=None, + stage=None, + path=None, + duration_num=None, + group_time_start=0, + group_clipid=None, + original_clipid=None, + emb=None, + multi_factor=None, + similar_clipseq=None, + rythm: float = None, + **kwargs + ): + """ + Args: + time_start (float): 开始时间,秒为单位,对应该媒体文件的, 和media_map.json上的序号一一对应 + duration (_type_): 片段持续时间 + clipid (int, or [int]): 由media_map提供的片段序号, 和media_map.json上的序号一一对应 + media_type (str, optional): music, video,text, Defaults to None. + mediaid (int): 多媒体id, 当clipid是列表时,表示该片段是个融合片段 + timepoint_type(int, ): 开始点的转场类型. Defaults to None. + text(str, optional): 该片段的文本描述,音乐可以是歌词,视频可以是台词,甚至可以是弹幕. Defaults to None. + stage(str, optional): 该片段在整个媒体文件中的结构位置,如音乐的intro、chrous、vesa,视频的片头、片尾、开始、高潮、转场等. Defaults to None. + path (_type_, optional): 该媒体文件的路径,用于后续媒体读取、处理. Defaults to None. + duration_num (_type_, optional): 片段持续帧数, Defaults to None. + group_time_start (int, optional): 当多歌曲、多视频剪辑时,group_time_start 表示该片段所对应的子媒体前所有子媒体的片段时长总和。 + 默认0, 表示只有1个媒体文件. Defaults to 0. + group_clipid (int, optional): # MediaInfo.sub_meta_info 中的实际序号. + original_clipid (None or [int], optional): 有些片段由其他片段合并,该字段用于片段来源,id是 media_map.json 中的实际序号. Defaults to None. + emb (np.array, optional): 片段 综合emb,. Defaults to None. + multi_factor (MultiFactorFeature), optional): 多维度特征. Defaults to None. + similar_clipseq ([Clip]], optional): 与该片段相似的片段，具体结构待定义. Defaults to None. + """ + self.media_type = media_type + self.mediaid = mediaid + self.time_start = time_start + self.duration = duration + self.clipid = clipid + self.path = path + self.timepoint_type = timepoint_type + self.text = text + self.stage = stage + self.group_time_start = group_time_start + self.group_clipid = group_clipid + self.duration_num = duration_num + self.original_clipid = original_clipid if original_clipid is not None else [] + self.emb = emb + self.multi_factor = multi_factor + self.similar_clipseq = similar_clipseq + self.rythm = rythm + # TODO: 目前谱面中会有一些不必要的中间结果，比较占内存，现在代码里删掉，待后续数据协议确定 + kwargs = {k: v for k, v in kwargs.items()} + self.__dict__.update(kwargs) + self.preprocess() + + def preprocess(self): + pass + + def spread_parameters(self): + pass + + @property + def time_end( + self, + ): + return self.time_start + self.duration + + @property + def mvp_clip(self): + """读取实际的片段数据为moviepy格式 + + Raises: + NotImplementedError: _description_ + """ + raise NotImplementedError + + +class ClipSeq(object): + """媒体片段序列""" + + ClipClass = Clip + + def __init__(self, clips) -> None: + """_summary_ + + Args: + clips ([Clip]]): 媒体片段序列 + """ + if not isinstance(clips, list): + clips = [clips] + if len(clips) == 0: + self.clips = [] + elif isinstance(clips[0], dict): + self.clips = [self.ClipClass(**d) for d in clips] + else: + self.clips = clips + + def set_clip_value(self, k, v): + """给序列中的每一个clip 赋值""" + for i in range(len(self.clips)): + self.clips[i].__setattr__(k, v) + + def __len__( + self, + ): + return len(self.clips) + + def merge(self, other, group_time_start_delta=None, groupid_delta=None): + """融合其他ClipSeq。media_info 融合时需要记录 clip 所在的 groupid 和 group_time_start，delta用于表示变化 + + Args: + other (ClipSeq): 待融合的ClipSeq + group_time_start_delta (float, optional): . Defaults to None. + groupid_delta (int, optional): _description_. Defaults to None. + """ + if group_time_start_delta is not None or groupid_delta is not None: + for i, clip in enumerate(other): + if group_time_start_delta is not None: + clip.group_time_start += group_time_start_delta + if groupid_delta is not None: + clip.groupid += groupid_delta + self.clips.extend(other.clips) + for i in range(len(self.clips)): + self.clips[i].group_clipid = i + + @property + def duration( + self, + ): + """Clip.duration的和 + + Returns: + float: 序列总时长 + """ + if len(self.clips) == 0: + return 0 + else: + return sum([c.duration for c in self.clips]) + + def __getitem__(self, i) -> Clip: + """支持索引和切片操作，如果输入是整数则返回Clip，如果是切片，则返回ClipSeq + + Args: + i (int or slice): 索引 + + Raises: + ValueError: 需要按照给的输入类型索引 + + Returns: + Clip or ClipSeq: + """ + if "int" in str(type(i)): + i = int(i) + if isinstance(i, int): + clip = self.clips[i] + return clip + elif isinstance(i, Iterable): + clips = [self.__getitem__(x) for x in i] + clipseq = ClipSeq(clips) + return clipseq + elif isinstance(i, slice): + if i.step is None: + step = 1 + else: + step = i.step + clips = [self.__getitem__(x) for x in range(i.start, i.stop, step)] + clipseq = ClipSeq(clips) + return clipseq + else: + raise ValueError( + "unsupported input, should be int or slice, but given {}, type={}".format( + i, type(i) + ) + ) + + def insert(self, idx, obj): + self.clips.insert(idx, obj) + + def append(self, obj): + self.clips.append(obj) + + def extend(self, objs): + self.clips.extend(objs) + + @property + def duration_seq_emb( + self, + ): + emb = np.array([c.duration for c in self.clips]) + return emb + + @property + def timestamp_seq_emb(self): + emb = np.array([c.time_start for c in self.clips]) + return emb + + @property + def rela_timestamp_seq_emb(self): + emb = self.timestamp_seq_emb / self.duration + return emb + + def get_factor_seq_emb(self, factor, dim): + emb = [] + for c in self.clips: + if factor not in c.multi_factor or c.multi_factor[factor] is None: + v = np.full(dim, np.inf) + else: + v = c.multi_factor[factor] + emb.append(v) + emb = np.stack(emb, axis=0) + return emb + + def semantic_seq_emb(self, dim): + return self.get_factor_seq_emb(factor="semantics", dim=dim) + + def emotion_seq_emb(self, dim): + return self.get_factor_seq_emb(factor="emotion", dim=dim) + + def theme_seq_emb(self, dim): + return self.get_factor_seq_emb(factor="theme", dim=dim) + + def to_dct( + self, + target_keys=None, + ignored_keys=None, + ): + if ignored_keys is None: + ignored_keys = ["kwargs", "audio_path", "lyric_path", "start", "end"] + clips = [ + clip.to_dct(target_keys=target_keys, ignored_keys=ignored_keys) + for clip in self.clips + ] + return clips + + @property + def mvp_clip(self): + """读取实际的片段数据为moviepy格式 + + Raises: + NotImplementedError: _description_ + """ + raise NotImplementedError + + +class ClipIds(object): + def __init__( + self, + clipids: list or int, + ) -> None: + """ClipSeq 中的 Clip序号，主要用于多个 Clip 融合后的 Clip, 使用场景如 + 1. 一个 MusicClip 可以匹配到多个 VideoClip，VideoClip 的索引便可以使用 ClipIds 定义。 + + Args: + clipids (list or int): ClipSeq 中的序号 + """ + self.clipids = clipids if isinstance(clipids, list) else [clipids] + + +class ClipIdsSeq(object): + def __init__(self, clipids_seq: list) -> None: + """多个 ClipIds，使用场景可以是 + 1. 将MediaClipSeq 进行重组，拆分重组成更粗粒度的ClipSeq； + + Args: + clipids_seq (list): 组合后的 ClipIds 列表 + """ + self.clipids_seq = ( + clipids_seq if isinstance(clipids_seq, ClipIds) else [clipids_seq] + ) + + +# TODO: metric后续可能是字典 +class MatchedClipIds(object): + def __init__( + self, id1: ClipIds, id2: ClipIds, metric: float = None, **kwargs + ) -> None: + """两种模态数据的片段匹配对，使用场景 可以是 + 1. 音乐片段和视频片段 之间的匹配关系， + + Args: + id1 (ClipIds): 第一种模态的片段 + id2 (ClipIds): 第二种模态的片段 + metric (float): 匹配度量距离 + """ + self.id1 = id1 if isinstance(id1, ClipIds) else ClipIds(id1) + self.id2 = id2 if isinstance(id2, ClipIds) else ClipIds(id2) + self.metric = metric + self.__dict__.update(**kwargs) + + +class MatchedClipIdsSeq(object): + def __init__(self, seq: list, metric: float = None, **kwargs) -> None: + """两种模态数据的序列匹配对，使用场景可以是 + 1. 音乐片段序列和视频片段序列 之间的匹配，每一个元素都是MatchedClipIds: + + Args: + seq (list): 两种模态数据的序列匹配对列表 + metric (float): 匹配度量距离 + """ + self.seq = seq + self.metric = metric + self.__dict__.update(**kwargs) diff --git a/MuseV/MMCM/mmcm/data/clip/__init__.py b/MuseV/MMCM/mmcm/data/clip/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e20ecac77f48377fb6d980ebd004e752ae0cf138 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/__init__.py @@ -0,0 +1,5 @@ +from .clip import Clip, ClipSeq +from .clipid import ClipIds, MatchedClipIds, ClipIdsSeq, MatchedClipIdsSeq +from .clip_process import find_idx_by_time, find_idx_by_clip, get_subseq_by_time, get_subseq_by_idx, clip_is_top, clip_is_middle, clip_is_end, abadon_old_return_new, reset_clipseq_id, insert_endclip, insert_startclip, drop_start_end_by_time, complete_clipseq, complete_gap +from .clip_stat import stat_clipseq_duration +from .clip_filter import ClipFilter, ClipSeqFilter \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/clip/clip.py b/MuseV/MMCM/mmcm/data/clip/clip.py new file mode 100755 index 0000000000000000000000000000000000000000..4afaab045e96aec9049a0204150ad116abe11bdd --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clip.py @@ -0,0 +1,197 @@ +from __future__ import annotations +from copy import deepcopy + +from typing import Iterable, List, Tuple, Dict, Hashable, Any, Union + +import numpy as np + +from ...utils.util import convert_class_attr_to_dict + + +from ..general.items import Items, Item +from .clipid import MatchedClipIds + + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +__all__ = ["Clip", "ClipSeq"] + + +class Clip(Item): + """媒体片段, 指转场点与转场点之间的部分""" + + def __init__( + self, + time_start: float, + duration: float, + clipid: int = None, + media_type: str = None, + mediaid: str = None, + timepoint_type: str = None, + text: str = None, + stage: str = None, + path: str = None, + duration_num: int = None, + similar_clipseq: MatchedClipIds = None, + dynamic: float = None, + **kwargs, + ): + """ + Args: + time_start (float): 开始时间,秒为单位,对应该媒体文件的, 和media_map.json上的序号一一对应 + duration (_type_): 片段持续时间 + clipid (int, or [int]): 由media_map提供的片段序号, 和media_map.json上的序号一一对应 + media_type (str, optional): music, video,text, Defaults to None. + mediaid (int): 多媒体id, 当clipid是列表时,表示该片段是个融合片段 + timepoint_type(int, ): 开始点的转场类型. Defaults to None. + text(str, optional): 该片段的文本描述,音乐可以是歌词,视频可以是台词,甚至可以是弹幕. Defaults to None. + stage(str, optional): 该片段在整个媒体文件中的结构位置,如音乐的intro、chrous、vesa,视频的片头、片尾、开始、高潮、转场等. Defaults to None. + path (str, optional): 该媒体文件的路径,用于后续媒体读取、处理. Defaults to None. + duration_num (_type_, optional): 片段持续帧数, Defaults to None. + similar_clipseq ([Clip]], optional): 与该片段相似的片段，具体结构待定义. Defaults to None. + """ + self.media_type = media_type + self.mediaid = mediaid + self.time_start = time_start + self.duration = duration + self.clipid = clipid + self.path = path + self.timepoint_type = timepoint_type + self.text = text + self.stage = stage + self.duration_num = duration_num + self.similar_clipseq = similar_clipseq + self.dynamic = dynamic + self.__dict__.update(**kwargs) + + def preprocess(self): + pass + + def spread_parameters(self): + pass + + @property + def time_end( + self, + ) -> float: + return self.time_start + self.duration + + def get_emb(self, key: str, idx: int) -> np.float: + return self.emb.get_value(key, idx) + + +class ClipSeq(Items): + """媒体片段序列""" + + def __init__(self, items: List[Clip] = None): + super().__init__(items) + self.clipseq = self.data + + def preprocess(self): + pass + + def set_clip_value(self, k: Hashable, v: Any) -> None: + """给序列中的每一个clip 赋值""" + for i in range(len(self.clipseq)): + self.clipseq[i].__setattr__(k, v) + + def __len__( + self, + ) -> int: + return len(self.clipseq) + + @property + def duration( + self, + ) -> float: + """Clip.duration的和 + + Returns: + float: 序列总时长 + """ + if len(self.clipseq) == 0: + return 0 + else: + return sum([c.duration for c in self.clipseq]) + + def __getitem__(self, i: Union[int, Iterable]) -> Union[Clip, ClipSeq]: + """支持索引和切片操作，如果输入是整数则返回Clip，如果是切片，则返回ClipSeq + + Args: + i (int or slice): 索引 + + Raises: + ValueError: 需要按照给的输入类型索引 + + Returns: + Clip or ClipSeq: + """ + if "int" in str(type(i)): + i = int(i) + if isinstance(i, int): + clip = self.clipseq[i] + return clip + elif isinstance(i, Iterable): + clipseq = [self.__getitem__(x) for x in i] + clipseq = ClipSeq(clipseq) + return clipseq + elif isinstance(i, slice): + if i.step is None: + step = 1 + else: + step = i.step + clipseq = [self.__getitem__(x) for x in range(i.start, i.stop, step)] + clipseq = ClipSeq(clipseq) + return clipseq + else: + raise ValueError( + "unsupported input, should be int or slice, but given {}, type={}".format( + i, type(i) + ) + ) + + @property + def mvp_clip(self): + """读取实际的片段数据为moviepy格式 + + Raises: + NotImplementedError: _description_ + """ + raise NotImplementedError + + @property + def duration_seq_emb( + self, + ) -> np.array: + emb = np.array([c.duration for c in self.clipseq]) + return emb + + @property + def timestamp_seq_emb(self) -> np.array: + emb = np.array([c.time_start for c in self.clipseq]) + return emb + + @property + def rela_timestamp_seq_emb(self) -> np.array: + duration_seq = [c.duration for c in self.clipseq] + emb = np.cumsum(duration_seq) / self.duration + return emb + + def get_emb(self, key: str, idx: int) -> np.float: + clip_start_idx = self.clipseq[0].clipid + clip_end_idx = self.clipseq[-1].clipid + # TODO: 待修改为更通用的形式 + if idx is None: + idx = range(clip_start_idx, clip_end_idx + 1) + elif isinstance(idx, int): + idx += clip_start_idx + elif isinstance(idx, Iterable): + idx = [x + clip_start_idx for x in idx] + else: + raise ValueError( + f"idx only support None, int, Iterable, but given {idx},type is {type(idx)}" + ) + return self.emb.get_value(key, idx=idx) diff --git a/MuseV/MMCM/mmcm/data/clip/clip_filter.py b/MuseV/MMCM/mmcm/data/clip/clip_filter.py new file mode 100755 index 0000000000000000000000000000000000000000..a9a47491988eb4b51a05f00b446e36ed50a620de --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clip_filter.py @@ -0,0 +1,46 @@ +from typing import Callable, List, Union + +from .clip import ClipSeq + +from .clip_process import reset_clipseq_id + + +class ClipFilter(object): + """clip滤波器，判断 Clip 是否符合标准 + + Args: + object (bool): 是否符合输入函数 + """ + + def __init__(self, funcs: Union[Callable, List[Callable]], logic_func: Callable=all) -> None: + """多个 clip 判断函数，通过 逻辑与、或当综合结果。 + + Args: + funcs (list of func): 列表判断函数 + logic_func (func, optional): all or any. Defaults to all. + """ + self.funcs = funcs if isinstance(funcs, list) else [funcs] + self.logic_func = logic_func + + def __call__(self, clip) -> bool: + flag = [func(clip) for func in self.funcs] + flag = self.logic_func(flag) + return flag + + + +# TODO +class ClipSeqFilter(object): + def __init__(self, filter: Callable) -> None: + self.filter = filter + + def __call__(self, clipseq: ClipSeq) -> ClipSeq: + new_clipseq = [] + n_clipseq = len(clipseq) + for i in range(n_clipseq): + clip = clipseq[i] + if self.filter(clip): + new_clipseq.append(clip) + new_clipseq = reset_clipseq_id(new_clipseq) + # logger.debug("ClipSeqFilter: clipseq length before={}, after={}".format(n_clipseq, len(new_clipseq))) + return new_clipseq diff --git a/MuseV/MMCM/mmcm/data/clip/clip_fusion.py b/MuseV/MMCM/mmcm/data/clip/clip_fusion.py new file mode 100755 index 0000000000000000000000000000000000000000..6c9f70595c115cd4a2c08fe03bb9c2defd8af594 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clip_fusion.py @@ -0,0 +1,64 @@ +from typing import List, Union, Callable + +from copy import deepcopy + +from .clip import ClipSeq +from .clip_process import reset_clipseq_id +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +# TODO: 不同类型的clip需要不同的融合方式 +def fuse_clips(s1: ClipSeq, s2: ClipSeq) -> ClipSeq: + """合并2个clip + + Args: + s1 (Clip): + s2 (Clip): + + Returns: + Clip: 合并后Clip + """ + if not isinstance(s2, list): + s2 = [s2] + s1 = deepcopy(s1) + for other_clip in s2: + s1.duration += other_clip.duration + if s1.stage is not None and other_clip.stage is not None: + # TODO：如何保留融合的clip信息 + s1.stage = "{}_{}".format(s1.stage, other_clip.stage) + s1.origin_clipid.extend(other_clip.origin_clipid) + if s1.timepoint_type is not None and other_clip.timepoint_type is not None: + s1.timepoint_type = "{}_{}".format( + s1.timepoint_type, other_clip.timepoint_type + ) + return s1 + + +# TODO: 不同的filter和fusion函数不适用同一种流程，待优化 +class ClipSeqFusion(object): + """_summary_ + + Args: + object (_type_): _description_ + """ + + def __init__(self, filter: Callable, fuse_func: Callable = None) -> None: + self.filter = filter + self.fuse_func = fuse_func + + def __call__(self, clipseq: ClipSeq) -> ClipSeq: + new_clipseq = [] + n_clipseq = len(clipseq) + for i in range(n_clipseq): + clip = clipseq[i] + if self.filter(clip): + new_clipseq.append(clip) + new_clipseq = reset_clipseq_id(new_clipseq) + logger.debug( + "ClipSeqFilter: clipseq length before={}, after={}".format( + n_clipseq, len(new_clipseq) + ) + ) + return new_clipseq diff --git a/MuseV/MMCM/mmcm/data/clip/clip_process.py b/MuseV/MMCM/mmcm/data/clip/clip_process.py new file mode 100755 index 0000000000000000000000000000000000000000..8766b02c370120a949f1f607ab32a62581ea5844 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clip_process.py @@ -0,0 +1,366 @@ +from functools import partial +from copy import deepcopy +from typing import Iterable, List, Tuple, Union +import bisect +import logging + +import numpy as np + + +from .clip import Clip, ClipSeq +from .clipid import ClipIds, ClipIdsSeq, MatchedClipIds, MatchedClipIdsSeq + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + +__all__ = [ + "find_idx_by_rela_time", + "find_idx_by_time", + "find_idx_by_clip", + "get_subseq_by_time", + "get_subseq_by_idx", + "clip_is_top", + "clip_is_middle", + "clip_is_end", + "abadon_old_return_new", + "reset_clipseq_id", + "insert_endclip", + "insert_startclip", + "drop_start_end_by_time", + "complete_clipseq", + "complete_gap", + "get_subseq_by_stages", + "find_time_by_stage", +] + + +def find_idx_by_rela_time(clipseq: ClipSeq, timepoint: float) -> int: + clipseq_duration = clipseq.duration + timepoint = clipseq_duration * timepoint + clipseq_times = [c.duration for c in clipseq] + clipseq_times.insert(0, 0) + clipseq_times = np.cumsum(clipseq_times) + idx = bisect.bisect_right(clipseq_times, timepoint) + idx = min(max(0, idx - 1), len(clipseq) - 1) + return idx + + +def find_idx_by_time(clipseq: ClipSeq, timepoint: float) -> int: + """寻找指定时间timepoint 在 clipseq 中的片段位置 + + Args: + clipseq (ClipSeq): 待寻找的片段序列 + timepoint (float): 指定时间位置 + + Returns: + _type_: _description_ + """ + clipseq_times = [c.time_start for c in clipseq] + idx = bisect.bisect_right(clipseq_times, timepoint) + idx = min(max(0, idx - 1), len(clipseq) - 1) + return idx + + +def find_idx_by_clip(clipseq: ClipSeq, clip: Clip, eps: float = 1e-4) -> int: + """通过计算目标clip和clipseq中所有候选clip的交集占比来找最近clip + + Args: + clipseq (ClipSeq): 候选clip序列 + clip (Clip): 目标clip + eps (float, optional): 最小交集占比. Defaults to 1e-4. + + Returns: + int: 目标clip在候选clip序列的位置，若无则为None + """ + timepoints = np.array([[c.time_start, c.time_start + c.duration] for c in clipseq]) + clip_time_start = clip.time_start + clip_duraiton = clip.duration + clip_time_end = clip_time_start + clip_duraiton + max_time_start = np.maximum(timepoints[:, 0], clip_time_start) + min_time_end = np.minimum(timepoints[:, 1], clip_time_end) + intersection = min_time_end - max_time_start + intersection_ratio = intersection / clip_duraiton + max_intersection_ratio = np.max(intersection_ratio) + idx = np.argmax(intersection_ratio) if max_intersection_ratio > eps else None + return idx + + +def get_subseq_by_time( + clipseq: ClipSeq, + start: float = 0, + duration: float = None, + end: float = 1, + eps: float = 1e-2, +) -> ClipSeq: + """根据时间对媒体整体做掐头去尾，保留中间部分。，也可以是大于1的数。 + start和end如果是0-1的小数，则认为是是相对时间位置，实际位置会乘以duration； + start和end如果是大于1的数，则是绝对时间位置。 + + Args: + clipseq (ClipSeq): 待处理的序列 + start (float,): 保留部分的开始，. Defaults to 0. + duration (float, optional): 媒体文件当前总时长 + end (float, optional): 保留部分的结尾. Defaults to 1. + + Returns: + ClipSeq: 处理后的序列 + """ + if (start == 0 or start is None) and (end is None or end == 1): + logger.warning("you should set start or end") + return clipseq + if duration is None: + duration = clipseq.duration + if start is None or start == 0: + clip_start_idx = 0 + else: + if start < 1: + start = start * duration + clip_start_idx = find_idx_by_time(clipseq, start) + if end is None or end == 1 or np.abs(duration - end) < eps: + clip_end_idx = -1 + else: + if end < 1: + end = end * duration + clip_end_idx = find_idx_by_time(clipseq, end) + if clip_end_idx != -1 and clip_start_idx >= clip_end_idx: + logger.error( + f"clip_end_idx({clip_end_idx}) should be > clip_start_idx({clip_start_idx})" + ) + subseq = get_subseq_by_idx(clipseq, clip_start_idx, clip_end_idx) + return subseq + + +def get_subseq_by_idx(clipseq: ClipSeq, start: int = None, end: int = None) -> ClipSeq: + """通过指定索引范围，切片子序列 + + Args: + clipseq (ClipSeq): + start (int, optional): 开始索引. Defaults to None. + end (int, optional): 结尾索引. Defaults to None. + + Returns: + _type_: _description_ + """ + if start is None and end is None: + return clipseq + if start is None: + start = 0 + if end is None: + end = len(clipseq) + return clipseq[start:end] + + +def clip_is_top(clip: Clip, total: float, th: float = 0.1) -> bool: + """判断Clip是否属于开始部分 + + Args: + clip (Clip): + total (float): 所在ClipSeq总时长 + th (float, optional): 开始范围的截止位置. Defaults to 0.05. + + Returns: + Bool: 是不是头部Clip + """ + clip_time = clip.time_start + if clip_time / total <= th: + return True + else: + return False + + +def clip_is_end(clip: Clip, total: float, th: float = 0.9) -> bool: + """判断Clip是否属于结尾部分 + + Args: + clip (Clip): + total (float): 所在ClipSeq总时长 + th (float, optional): 结尾范围的开始位置. Defaults to 0.9. + + Returns: + Bool: 是不是尾部Clip + """ + clip_time = clip.time_start + clip.duration + if clip_time / total >= th: + return True + else: + return False + + +def clip_is_middle( + clip: Clip, total: float, start: float = 0.05, end: float = 0.9 +) -> bool: + """判断Clip是否属于中间部分 + + Args: + clip (Clip): + total (float): 所在ClipSeq总时长 + start (float, optional): 中间范围的开始位置. Defaults to 0.05. + start (float, optional): 中间范围的截止位置. Defaults to 0.9. + + Returns: + Bool: 是不是中间Clip + """ + if start >= 0 and start < 1: + start = total * start + if end > 0 and end <= 1: + end = total * end + clip_time_start = clip.time_start + clip_time_end = clip.time_start + clip.duration + if (clip_time_start >= start) and (clip_time_end <= end): + return True + else: + return False + + +def abadon_old_return_new(s1: Clip, s2: Clip) -> Clip: + """特殊的融合方式 + Args: + + s1 (Clip): 靠前的clip + s2 (Clip): 靠后的clip + + Returns: + Clip: 融合后的Clip + """ + return s2 + + +# TODO：待确认是否要更新clipid，不方便对比着json进行debug +def reset_clipseq_id(clipseq: ClipSeq) -> ClipSeq: + for i in range(len(clipseq)): + if isinstance(clipseq[i], dict): + clipseq[i]["clipid"] = i + else: + clipseq[i].clipid = i + return clipseq + + +def insert_startclip(clipseq: ClipSeq) -> ClipSeq: + """给ClipSeq插入一个开始片段。 + + Args: + clipseq (ClipSeq): + clip_class (Clip, optional): 插入的Clip类型. Defaults to Clip. + + Returns: + ClipSeq: 插入头部Clip的新ClipSeq + """ + if clipseq[0].time_start > 0: + start = clipseq.ClipClass( + time_start=0, duration=round(clipseq[0].time_start, 3), timepoint_type=0 + ) + clipseq.insert(0, start) + clipseq = reset_clipseq_id(clipseq) + return clipseq + + +def insert_endclip(clipseq: ClipSeq, duration: float) -> ClipSeq: + """给ClipSeq插入一个尾部片段。 + + Args: + clipseq (ClipSeq): + duration(float, ): 序列的总时长 + clip_class (Clip, optional): 插入的Clip类型. Defaults to Clip. + + Returns: + ClipSeq: 插入尾部Clip的新ClipSeq + """ + clipseq_endtime = clipseq[-1].time_start + clipseq[-1].duration + if duration - clipseq_endtime > 1: + end = clipseq.ClipClass( + time_start=round(clipseq_endtime, 3), + duration=round(duration - clipseq_endtime, 3), + timepoint_type=0, + ) + clipseq.append(end) + clipseq = reset_clipseq_id(clipseq) + return clipseq + + +def drop_start_end_by_time( + clipseq: ClipSeq, start: float, end: float, duration: float = None +): + return get_subseq_by_time(clipseq=clipseq, start=start, end=end, duration=duration) + + +def complete_clipseq( + clipseq: ClipSeq, duration: float = None, gap_th: float = 2 +) -> ClipSeq: + """绝大多数需要clipseq中的时间信息是连续、完备的，有时候是空的，需要补足的部分。 + 如歌词时间戳生成的music_map缺头少尾、中间有空的部分。 + + Args: + clipseq (ClipSeq): 待补集的序列 + duration (float, optional): 整个序列持续时间. Defaults to None. + gap_th (float, optional): 有时候中间空隙过短就会被融合到上一个片段中. Defaults to 2. + + Returns: + ClipSeq: 补集后的序列，时间连续、完备。 + """ + if isinstance(clipseq, list): + clipseq = ClipSeq(clipseq) + return complete_clipseq(clipseq=clipseq, duration=duration, gap_th=gap_th) + clipseq = complete_gap(clipseq, th=gap_th) + clipseq = insert_startclip(clipseq) + if duration is not None: + clipseq = insert_endclip(clipseq, duration) + return clipseq + + +def complete_gap(clipseq: ClipSeq, th: float = 2) -> ClipSeq: + """generate blank clip timepoint = 0，如果空白时间过短，则空白附到上一个歌词片段中。 + + + Args: + clipseq (ClipSeq): 原始的歌词生成的MusicClipSeq + th (float, optional): 有时候中间空隙过短就会被融合到上一个片段中. Defaults to 2. + + Returns: + ClipSeq: 补全后的 + """ + gap_clipseq = [] + clipid = 0 + for i in range(len(clipseq) - 1): + time_start = clipseq[i].time_start + duration = clipseq[i].duration + time_end = time_start + duration + next_time_start = clipseq[i + 1].time_start + time_diff = next_time_start - time_end + if time_diff >= th: + blank_clip = clipseq.ClipClass( + time_start=time_end, + duration=time_diff, + timepoint_type=0, + clipid=clipid, + ) + gap_clipseq.append(blank_clip) + clipid += 1 + else: + clipseq[i].duration = next_time_start - time_start + clipseq.extend(gap_clipseq) + clipseq.clips = sorted(clipseq.clips, key=lambda clip: clip.time_start) + reset_clipseq_id(clipseq) + return clipseq + + +def find_time_by_stage( + clipseq: ClipSeq, stages: Union[str, List[str]] = None +) -> Tuple[float, float]: + if isinstance(stages, list): + stages = [stages] + for clip in clipseq: + if clip.stage in stages: + return clip.time_start, clip.time_end + return None, None + + +def get_subseq_by_stages(clipseq: ClipSeq, stages: Union[str, List[str]]) -> ClipSeq: + if isinstance(stages, List): + stages = [stages] + start, _ = find_time_by_stage(clipseq, stages[0]) + _, end = find_time_by_stage(clipseq, stages[-1]) + if start1 is None: + start1 = 0 + if end2 is None: + end2 = clipseq.duration + subseq = get_subseq_by_time(clipseq=clipseq, start=start, end=end) + return subseq diff --git a/MuseV/MMCM/mmcm/data/clip/clip_stat.py b/MuseV/MMCM/mmcm/data/clip/clip_stat.py new file mode 100755 index 0000000000000000000000000000000000000000..ba4e826e5591f4ffbccace67dc75637be02bd7c7 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clip_stat.py @@ -0,0 +1,13 @@ +from typing import Tuple + +import numpy as np + +from .clip import ClipSeq + + +def stat_clipseq_duration( + clipseq: ClipSeq, +) -> Tuple[np.array, np.array]: + clip_duration = [clip.duration for clip in clipseq] + (hist, bin_edges) = np.histogram(clip_duration) + return hist, bin_edges diff --git a/MuseV/MMCM/mmcm/data/clip/clipid.py b/MuseV/MMCM/mmcm/data/clip/clipid.py new file mode 100755 index 0000000000000000000000000000000000000000..d323e825bee48aa8ea9efe3513cec532114b9f8e --- /dev/null +++ b/MuseV/MMCM/mmcm/data/clip/clipid.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +from typing import Union, List + +__all__ = [ + "ClipIds", + "ClipIdsSeq", + "MatchedClipIds", + "MatchedClipIdsSeq", +] + + +class ClipIds(object): + def __init__( + self, + clipids: Union[int, List[int]], + ) -> None: + """ClipSeq 中的 Clip序号，主要用于多个 Clip 融合后的 Clip, 使用场景如 + 1. 一个 MusicClip 可以匹配到多个 VideoClip，VideoClip 的索引便可以使用 ClipIds 定义。 + + Args: + clipids (list or int): ClipSeq 中的序号 + """ + self.clipids = clipids if isinstance(clipids, list) else [clipids] + + +class ClipIdsSeq(object): + def __init__(self, clipids_seq: List[ClipIds]) -> None: + """多个 ClipIds，使用场景可以是 + 1. 将MediaClipSeq 进行重组，拆分重组成更粗粒度的ClipSeq； + + Args: + clipids_seq (list): 组合后的 ClipIds 列表 + """ + self.clipids_seq = ( + clipids_seq if isinstance(clipids_seq, ClipIds) else [clipids_seq] + ) + + +# TODO: metric后续可能是字典 +class MatchedClipIds(object): + def __init__( + self, id1: ClipIds, id2: ClipIds, metric: float = None, **kwargs + ) -> None: + """两种模态数据的片段匹配对，使用场景 可以是 + 1. 音乐片段和视频片段 之间的匹配关系， + + Args: + id1 (ClipIds): 第一种模态的片段 + id2 (ClipIds): 第二种模态的片段 + metric (float): 匹配度量距离 + """ + self.id1 = id1 if isinstance(id1, ClipIds) else ClipIds(id1) + self.id2 = id2 if isinstance(id2, ClipIds) else ClipIds(id2) + self.metric = metric + self.__dict__.update(**kwargs) + + +class MatchedClipIdsSeq(object): + def __init__(self, seq: List[MatchedClipIds], metric: float = None, **kwargs) -> None: + """两种模态数据的序列匹配对，使用场景可以是 + 1. 音乐片段序列和视频片段序列 之间的匹配，每一个元素都是MatchedClipIds: + + Args: + seq (list): 两种模态数据的序列匹配对列表 + metric (float): 匹配度量距离 + """ + self.seq = seq + self.metric = metric + self.__dict__.update(**kwargs) diff --git a/MuseV/MMCM/mmcm/data/crawl/__init__.py b/MuseV/MMCM/mmcm/data/crawl/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/data/crawl/download.py b/MuseV/MMCM/mmcm/data/crawl/download.py new file mode 100755 index 0000000000000000000000000000000000000000..db74afc21f7e6816ba64b629acd2c22883e44e1a --- /dev/null +++ b/MuseV/MMCM/mmcm/data/crawl/download.py @@ -0,0 +1,72 @@ + +from collections import namedtuple +from typing import NamedTuple, Tuple, List +import logging +import os +import numpy as np +import subprocess + +import requests + +import wget + +from .youtube import download_youtube +from .flicker import download_flickr +from .ffmpeg import ffmpeg_load + +logger = logging.getLogger(__name__) + +# DownloadStatus = namedtuple("DownloadStatus", ["status_code", "msg"]) + +status_code = {0: "download: succ", + -1: "download: failed", + -2: "clip: failed", + -3: "directory not exists", + -4: "skip task", + - 404: "param error"} + + +def download_with_request(url, path): + res = requests.get(url) + if res.status_code == '200' or res.status_code == 200: + with open(path, "wb") as f: + f.write(res.content) + else: + print('request failed') + return path + +def download_video(url, save_path:str=None, save_dir:str=None, basename:str=None, filename:str=None, format:str=None, data_type: str="wget", **kwargs) -> Tuple[int, str]: + if save_path is None: + if basename is None: + basename = f"{filename}.{format}" + save_path = os.path.join(save_dir, basename) + if save_dir is None: + save_dir = os.path.dirname(save_path) + if basename is None: + basename = os.path.basename(save_path) + if filename is None: + filename, format = os.path.splitext(basename) + os.makedirs(save_dir, exist_ok=True) + + if os.path.exists(save_path): + return (-4, save_path) + + try: + if data_type == "requests": + save_path = download_with_request(url=url, path=save_path) + elif data_type == "wget": + save_path = wget.download(url=url, out=save_path) + elif data_type == "youtube": + save_path = download_youtube(url, format=format, save_dir=save_dir, filename=basename) + elif data_type == "flickr": + save_path = download_flickr(url, save_path) + elif data_type == "ffmpeg": + code = ffmpeg_load(url=url, save_path=save_path) + else: + raise ValueError(f"data_type shoulbe one of [wget, youtube, flickr, ffmpeg], but given {data_type}") + except Exception as e: + logger.error("failed download file {} to {} failed!".format(url, save_path)) + logger.exception(e) + return (-1, None) + + return (0, save_path) diff --git a/MuseV/MMCM/mmcm/data/crawl/error.py b/MuseV/MMCM/mmcm/data/crawl/error.py new file mode 100755 index 0000000000000000000000000000000000000000..2e26dc8734521b6a47118bc86ffe85f9edddf804 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/crawl/error.py @@ -0,0 +1,20 @@ + + +class SubprocessError(Exception): + """ + Exception object that contains information about an error that occurred + when running a command line command with a subprocess. + """ + + def __init__(self, cmd, return_code, stdout, stderr, *args): + msg = 'Got non-zero exit code ({1}) from command "{0}": {2}' + if stderr.strip(): + err_msg = stderr + else: + err_msg = stdout + msg = msg.format(cmd[0], return_code, err_msg) + self.cmd = cmd + self.cmd_return_code = return_code + self.cmd_stdout = stdout + self.cmd_stderr = stderr + super(SubprocessError, self).__init__(msg, *args) diff --git a/MuseV/MMCM/mmcm/data/crawl/ffmpeg.py b/MuseV/MMCM/mmcm/data/crawl/ffmpeg.py new file mode 100755 index 0000000000000000000000000000000000000000..1f2651df39a179b48c85610274d745fb1b0e9ad5 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/crawl/ffmpeg.py @@ -0,0 +1,39 @@ +import subprocess + +from .error import SubprocessError + + +class FfmpegInvalidURLError(Exception): + """ + Exception raised when a 4XX or 5XX error is returned when making a request + """ + + def __init__(self, url, error, *args): + self.url = url + self.error = error + msg = 'Got error when making request to "{}": {}'.format(url, error) + super(FfmpegInvalidURLError, self).__init__(msg, *args) + + +def ffmpeg_load(url: str, save_path: str) -> str: + + def run(cmd): + proc = subprocess.Popen( + cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + stdout, stderr = proc.communicate() + return_code = proc.returncode + + if return_code != 0: + raise SubprocessError( + cmd, return_code, stdout.decode(), stderr.decode()) + return return_code + + command = ['ffmpeg', '-n', '-i', url, '-t', '10', '-f', 'mp4', + '-r', '30', '-vcodec', 'h264', save_path, '-loglevel', 'error'] + code = run(command) + return code + + + + + diff --git a/MuseV/MMCM/mmcm/data/crawl/flicker.py b/MuseV/MMCM/mmcm/data/crawl/flicker.py new file mode 100755 index 0000000000000000000000000000000000000000..6a05cf468878b6986541a3969ae581b4565ec42a --- /dev/null +++ b/MuseV/MMCM/mmcm/data/crawl/flicker.py @@ -0,0 +1,22 @@ +import os + +from .ffmpeg import ffmpeg_load + + +def extract_flickr_id(url): + return url.strip('/').split('/')[-4] + + +def download_flickr(url: str, save_path: str) -> str: + code = -1 + code = ffmpeg_load(url=url, + save_path=save_path) + if code == 0: + return (code, save_path) + # only retry when failed! + flickr_id = extract_flickr_id(url) + url = 'https://www.flickr.com/video_download.gne?id={}'.format( + flickr_id) + code = ffmpeg_load(url=url, + save_path=save_path) + return save_path \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/crawl/youtube.py b/MuseV/MMCM/mmcm/data/crawl/youtube.py new file mode 100755 index 0000000000000000000000000000000000000000..027c2bac638ba4963940a614c6d2555a83a2ce23 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/crawl/youtube.py @@ -0,0 +1,13 @@ + +import os + +from pytube import YouTube + + +def download_youtube(url, format, save_dir, filename): + youtube = YouTube(url) + streams = youtube.streams.filter(progressive=True, + file_extension=format) + save_path = streams.get_highest_resolution().download(output_path=save_dir, + filename=filename) + return save_path \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/emb/__init__.py b/MuseV/MMCM/mmcm/data/emb/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..6ac25b70a9c17b65e8fd80c176004eb3447d542e --- /dev/null +++ b/MuseV/MMCM/mmcm/data/emb/__init__.py @@ -0,0 +1,2 @@ +from .emb import * +from .h5py_emb import H5pyMediaMapEmb, H5pyMediaMapEmbProxy diff --git a/MuseV/MMCM/mmcm/data/emb/emb.py b/MuseV/MMCM/mmcm/data/emb/emb.py new file mode 100755 index 0000000000000000000000000000000000000000..631604ce64139095330df347c6a02f7f755a9496 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/emb/emb.py @@ -0,0 +1,104 @@ +"""用于将 mediamap中的emb存储独立出去，仍处于开发中 +""" +import logging + +import numpy as np + + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + +__all__ = ["MediaMapEmb"] + + +class MediaMapEmb(object): + def __init__(self, path: str) -> None: + """ + OfflineEmb = { + "overall_algo": Emb, # 整个文件的Emb + # 整个文件的多维度 Emb + "theme": np.array, # 主题， + "emotion_algo": np.array, # 情绪， + "semantic_algo": np.array, # 语义 + + "clips_overall_algo": np.array, n_clip x clip_emb + "clips_emotion_algo": np.array, n_clip x clip_emb + "clips_semantic_algo": np.array, n_clip x clip_emb + "clips_theme_algo": np.array, n_clip x clip_emb + + "scenes_overall_algo": np.array, n_scenes x scene_emb + "scenes_emotion_algo": np.array, n_scenes x scene_emb + "scenes_semantic_algo": np.array, n_scenes x scene_emb + "scenes_theme_algo": E np.arraymb, n_scenes x scene_emb + # 片段可以是转场切分、MusicStage等, clips目前属于转场切分片段 + # 若后续需要新增段落分割，可以和clips同级新增 stage字段。 + + "frames_overall_algo": np.array, n_frames x frame_emb + "frames_emotion_algo": np.array, n_frames x frame_emb + "frames_semantic_algo": np.array, n_frames x frame_emb + "frames_theme_algo": np.array, n_frames x frame_emb + "frames_objs": { + "frame_id": { # + "overall_algo": np.array, n_objs x obj_emb + "emotion_algo": np.array, n_objs x obj_emb + "semantic_algo": np.array, n_objs x obj_emb + "theme_algo": np.array, n_objs x obj_emb + } + } + "roles_algo": { + "roleid": np.array, n x obj_emb + } + } + + + Args: + path (str): hdf5 存储路径 + """ + self.path = path + + def get_value(self, key, idx=None): + raise NotImplementedError + + def __getitem__(self, key): + return self.get_value(key) + + def get_media(self, factor, algo): + return self.get_value(f"{factor}_{algo}") + + def get_clips(self, factor, algo, idx=None): + return self.get_value(f"clips_{factor}_{algo}", idx=idx) + + def get_frames(self, factor, algo, idx=None): + return self.get_value(f"frames_{factor}_{algo}", idx=idx) + + def get_frame_objs(self, frame_idx, factor, algo, idx=None): + return self.get_value(["frames_objs", frame_idx, f"{factor}_{algo}"], idx=idx) + + def set_value(self, key, value, idx=None): + raise NotImplementedError + + def set_media(self, factor, value, algo): + self.set_value([f"{factor}_{algo}"], value) + + def set_clips(self, factor, value, algo, idx=None): + self.set_value([f"clips_{factor}_{algo}"], value, idx=idx) + + def set_frames(self, factor, value, algo, idx=None): + self.set_value([f"frames_{factor}_{algo}"], value) + + def set_frame_objs(self, frame_idx, factor, value, algo, idx=None): + return self.set_value( + ["frames_objs", frame_idx, f"{factor}_{algo}"], value, idx=idx + ) + + def set_roles(self, algo, value, idx=None): + return self.set_value(f"roles_{algo}", value, idx=idx) + + def get_roles(self, algo, idx=None): + return self.get_value(f"roles_{algo}", idx=idx) + + def __setitem__(self, key, value): + self.set_value(self, key, value) + + +class MediaMapEmbProxy(MediaMapEmb): + pass diff --git a/MuseV/MMCM/mmcm/data/emb/h5py_emb.py b/MuseV/MMCM/mmcm/data/emb/h5py_emb.py new file mode 100755 index 0000000000000000000000000000000000000000..4391f052ced20c00475b5424f7a1fd6ab3c47943 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/emb/h5py_emb.py @@ -0,0 +1,119 @@ +from typing import Union, List +import logging + +import h5py +import numpy as np + +from .emb import MediaMapEmb + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + +__all__ = ["H5pyMediaMapEmb", "save_value_with_h5py"] + + +def save_value_with_h5py( + path: str, + value: Union[np.ndarray, None], + key: str, + idx: Union[int, List[int]] = None, + dtype=None, + shape=None, + overwrite: bool = False, +): + with h5py.File(path, "a") as f: + if dtype is None: + dtype = value.dtype + if shape is None: + shape = value.shape + del_key = False + if key in f: + if overwrite: + del_key = True + if f[key].dtype != h5py.special_dtype(vlen=str): + if f[key].shape != value.shape: + del_key = True + if del_key: + del f[key] + if key not in f: + f.create_dataset(key, shape=shape, dtype=dtype) + if idx is None: + f[key][...] = value + else: + f[key][idx] = value + + +class H5pyMediaMapEmb(MediaMapEmb): + def __init__(self, path: str) -> None: + """ + OfflineEmb = { + "overall_algo": Emb, # 整个文件的Emb + # 整个文件的多维度 Emb + "theme": np.array, # 主题， + "emotion_algo": np.array, # 情绪， + "semantic_algo": np.array, # 语义 + + "clips_overall_algo": np.array, n_clip x clip_emb + "clips_emotion_algo": np.array, n_clip x clip_emb + "clips_semantic_algo": np.array, n_clip x clip_emb + "clips_theme_algo": np.array, n_clip x clip_emb + + "scenes_overall_algo": np.array, n_scenes x scene_emb + "scenes_emotion_algo": np.array, n_scenes x scene_emb + "scenes_semantic_algo": np.array, n_scenes x scene_emb + "scenes_theme_algo": E np.arraymb, n_scenes x scene_emb + # 片段可以是转场切分、MusicStage等, clips目前属于转场切分片段 + # 若后续需要新增段落分割，可以和clips同级新增 stage字段。 + + "frames_overall_algo": np.array, n_frames x frame_emb + "frames_emotion_algo": np.array, n_frames x frame_emb + "frames_semantic_algo": np.array, n_frames x frame_emb + "frames_theme_algo": np.array, n_frames x frame_emb + "frames_objs_algo": { + "frame_id_algo": { # + "overall_algo": np.array, n_objs x obj_emb + "emotion_algo": np.array, n_objs x obj_emb + "semantic_algo": np.array, n_objs x obj_emb + "theme_algo": np.array, n_objs x obj_emb + } + } + "roles_algo": { + "roleid": np.array, n x obj_emb + } + } + + Args: + path (str): hdf5 存储路径 + """ + super().__init__(path) + # 待优化支持 with open 的方式来读写 + self.f = h5py.File(path, "a") + + def _keys_index(self, key): + if not isinstance(key, list): + key = [key] + key = "/".join([str(x) for x in key if x is not None]) + return key + + def get_value(self, key, idx=None): + new_key = self._keys_index(key) + if idx is None: + data = np.array(self.f[new_key]) + else: + data = np.array(self.f[new_key][idx]) + return data + + def set_value(self, key, value, idx=None): + new_key = self._keys_index(key) + if new_key not in self.f: + self.f.create_dataset(new_key, shape=value.shape, dtype=value.dtype) + if idx is None: + self.f[new_key][...] = value + else: + self.f[new_key][idx] = value + + def close(self): + self.f.close() + + +class H5pyMediaMapEmbProxy(H5pyMediaMapEmb): + pass diff --git a/MuseV/MMCM/mmcm/data/emb/json_emb.py b/MuseV/MMCM/mmcm/data/emb/json_emb.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/data/emb/numpy_emb.py b/MuseV/MMCM/mmcm/data/emb/numpy_emb.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/data/extract_feature/__init__.py b/MuseV/MMCM/mmcm/data/extract_feature/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/data/extract_feature/base_extract_feature.py b/MuseV/MMCM/mmcm/data/extract_feature/base_extract_feature.py new file mode 100755 index 0000000000000000000000000000000000000000..d253ea706f2ff857e730c34adea72676769cacad --- /dev/null +++ b/MuseV/MMCM/mmcm/data/extract_feature/base_extract_feature.py @@ -0,0 +1,28 @@ +from typing import List, Union, Any + +import torch +from torch import nn +import numpy as np +import h5py + + +class BaseFeatureExtractor(nn.Module): + def __init__(self, device: str = "cpu", dtype=torch.float32, name: str = None): + super().__init__() + self.device = device + self.dtype = dtype + self.name = name + + def extract( + self, data: Any, return_type: Union[str, str] = "numpy" + ) -> Union[np.ndarray, torch.tensor]: + raise NotADirectoryError + + def __call__(self, *args: Any, **kwds: Any) -> Any: + return self.extract(*args, **kwds) + + def save_with_h5py(self, f: Union[h5py.File, str], *args, **kwds): + raise NotImplementedError + + def forward(self, *args: Any, **kwds: Any) -> Any: + return self.extract(*args, **kwds) diff --git a/MuseV/MMCM/mmcm/data/general/__init__.py b/MuseV/MMCM/mmcm/data/general/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..134eaf6fff07fba3089ad506e8612b8186d7cb8c --- /dev/null +++ b/MuseV/MMCM/mmcm/data/general/__init__.py @@ -0,0 +1 @@ +from .items import Items \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/general/items.py b/MuseV/MMCM/mmcm/data/general/items.py new file mode 100755 index 0000000000000000000000000000000000000000..2252013e6c424e0bc398e1489667d000542923ee --- /dev/null +++ b/MuseV/MMCM/mmcm/data/general/items.py @@ -0,0 +1,69 @@ +from collections import UserList +from collections.abc import Iterable +from typing import Iterator, Any, List + +from ...utils.util import convert_class_attr_to_dict + +__all__ = ["Item", "Items"] + + +class Item(object): + def __init__(self) -> None: + pass + + def to_dct(self, target_keys: List[str] = None, ignored_keys: List[str] = None): + base_ignored_keys = [ + "kwargs", + ] + if isinstance(ignored_keys, list): + base_ignored_keys.extend(ignored_keys) + elif isinstance(ignored_keys, str): + base_ignored_keys.append(ignored_keys) + else: + pass + return convert_class_attr_to_dict( + self, target_keys=target_keys, ignored_keys=base_ignored_keys + ) + + def preprocess(self): + pass + + +class Items(UserList): + def __init__( + self, + data: Any = None, + ): + if data is None: + data = list() + if not isinstance(data, list): + data = [data] + super().__init__(data) + + def __len__(self): + return len(self.data) + + def __getitem__(self, i): + return self.data[i] + + def __delitem__(self, i): + del self.data[i] + + def __setitem__(self, i, v): + self.data[i] = v + + def insert(self, i, v): + self.data.insert(i, v) + + def __str__(self): + return str(self.data) + + def to_dct(self, target_keys: List[str] = None, ignored_keys: List[str] = None): + items = [item.to_dct(target_keys, ignored_keys) for item in self.data] + return items + + def __iter__(self) -> Iterator: + return iter(self.data) + + def preprocess(self): + pass diff --git a/MuseV/MMCM/mmcm/data/media_map/__init__.py b/MuseV/MMCM/mmcm/data/media_map/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..736ae38ada810bfb2d0ee4e5cef3dfc5c28a425b --- /dev/null +++ b/MuseV/MMCM/mmcm/data/media_map/__init__.py @@ -0,0 +1 @@ +from .media_map import MetaInfo, MediaMap, MetaInfoList \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/data/media_map/media_map.py b/MuseV/MMCM/mmcm/data/media_map/media_map.py new file mode 100755 index 0000000000000000000000000000000000000000..0e34f128fb9a8d654cbb1a9fa14f4c1d17dcc034 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/media_map/media_map.py @@ -0,0 +1,393 @@ +from __future__ import annotations +import bisect + +import logging +from copy import deepcopy + +from functools import partial +from typing import Any, Callable, Iterable, List, Union, Tuple, Dict + +import numpy as np +from ..clip.clip_process import get_subseq_by_time +from ..clip.clip_stat import stat_clipseq_duration +from ..clip import Clip, ClipSeq, ClipIds, MatchedClipIds, MatchedClipIdsSeq +from .media_map_process import get_sub_mediamap_by_time +from ..emb import MediaMapEmb, H5pyMediaMapEmb +from ..general.items import Item, Items +from ...utils.data_util import pick_subdct +from ...utils.util import convert_class_attr_to_dict, load_dct_from_file + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +__all__ = ["MetaInfo", "MetaInfoList", "MediaMap", "MediaMapSeq"] + + +class MetaInfo(Item): + """歌曲、视频等媒体文件级别的元信息""" + + def __init__( + self, + mediaid=None, + media_name=None, + media_duration=None, + signature=None, + media_path: str = None, + media_map_path: str = None, + start: float = None, + end: float = None, + ext=None, + **kwargs, + ): + super(MetaInfo).__init__() + self.mediaid = mediaid + self.media_name = media_name + self.media_duration = media_duration + self.signature = signature + self.media_path = media_path + self.media_map_path = media_map_path + self.start = start + self.end = end + self.ext = ext + self.__dict__.update(**kwargs) + self.preprocess() + + def preprocess(self): + self.set_start_end() + + def set_start_end(self): + if self.start is None: + self.start = 0 + elif self.start >= 0 and self.start <= 1: + self.start = self.start * self.media_duration + + if self.end is None: + self.end = self.media_duration + elif self.end >= 0 and self.end <= 1: + self.end = self.end * self.media_duration + + +class MetaInfoList(Items): + """媒体元数据列表，主要用于多歌曲、多视频剪辑时存储原单一媒体文件的元信息""" + + def __init__(self, items: Union[MetaInfo, List[MetaInfo]] = None): + """ + Args: + meta_info_list (list, optional): MetaInfo 列表. Defaults to None. + """ + if items is None: + items = [] + else: + items = items if isinstance(items, list) else [items] + super().__init__(items) + self.meta_info_list = self.items + if len(self.items) > 1: + self.reset() + + def __len__(self): + return len(self.meta_info_list) + + def __getitem__(self, i) -> MetaInfo: + return self.meta_info_list[i] + + @property + def groupnum(self) -> int: + return len(self.meta_info_list) + + +class MediaMap(object): + """媒体信息基类，也可以理解为音乐谱面、视觉谱面、音游谱面基类。主要有 MetaInfo、MetaInfoList、ClipSeq 属性。 + 不同的媒体信息的 属性 类会有不同，所以在类变量里做定义。如有变化，可以定义自己的属性类。 + """ + + def __init__( + self, + meta_info: MetaInfo = None, + clipseq: ClipSeq = None, + stageseq: ClipSeq = None, + frameseq: ClipSeq = None, + emb: H5pyMediaMapEmb = None, + **kwargs, + ): + """用于存储media的相关信息，media_info是json或直接字典 + + Args: + meta_info (MetaInfo): 当sub_meta_info不为None时, meta_info由sub_meta_info整合而成 + sub_meta_info (None or [MetaInfo]): 当多个MediaInfo拼在一起时,用于保留子MediaInfo的信息 + clipseq (ClipSeq): # 按照clipidx排序; + stageseq (ClipSeq): # 比 clipseq 更高纬度的片段划分，例如clips是镜头分割，stages是scenes分割；clips是关键点分割，stages是结构分割； + frameseq (ClipSeq): # 比 clipseq 更低纬度的片段划分 + kwargs (dict, optional): 所有相关信息都会作为 meta_info 的补充，赋值到 meta_info 中 + """ + self.meta_info = meta_info + self.clipseq = clipseq + self.frameseq = frameseq + self.stageseq = stageseq + self.emb = emb + self.meta_info.__dict__.update(**kwargs) + self.preprocess() + + def preprocess( + self, + ): + if (self.meta_info.start != 0 and self.meta_info.start is not None) or ( + self.meta_info.end is not None and self.meta_info.end == 1 + ): + self.drop_head_and_tail() + self.meta_info.preprocess() + if self.clipseq is not None: + self.clipseq.preprocess() + if self.frameseq is not None: + self.frameseq.preprocess() + if self.stageseq is not None: + self.stageseq.preprocess() + self.clip_start_idx = self.clipseq[0].clipid + self.clip_end_idx = self.clipseq[-1].clipid + + def drop_head_and_tail(self) -> MediaMap: + self.clipseq = get_subseq_by_time( + self.clipseq, + start=self.meta_info.start, + end=self.meta_info.end, + duration=self.meta_info.media_duration, + ) + if self.stageseq is not None: + self.stageseq = get_subseq_by_time( + self.clipseq, + start=self.meta_info.start, + end=self.meta_info.end, + duration=self.meta_info.media_duration, + ) + + def set_clip_value(self, k, v): + """为clipseq中的每个clip赋值， + + Args: + k (str): Clip中字段名 + v (any): Clip中字段值 + """ + self.clipseq.set_clip_value(k, v) + + def spread_metainfo_2_clip( + self, target_keys: List = None, ignored_keys: List = None + ) -> None: + """将metainfo中的信息赋值到clip中，便于clip后面做相关处理。 + + Args: + target_keys ([str]): 待赋值的目标字段 + """ + dst = pick_subdct( + self.meta_info.__dict__, target_keys=target_keys, ignored_keys=ignored_keys + ) + for k, v in dst.items(): + self.set_clip_value(k, v) + + def spread_parameters(self, target_keys: list, ignored_keys) -> None: + """元数据广播，将 media_info 的元数据广播到 clip 中，以及调用 clip 自己的参数传播。""" + self.spread_metainfo_2_clip(target_keys=target_keys, ignored_keys=ignored_keys) + for clip in self.clipseq: + clip.spread_parameters() + + def stat( + self, + ): + """统计 media_info 相关信息，便于了解，目前统计内容有 + 1. 片段长度 + """ + self.stat_clipseq_duration() + + def stat_clipseq_duration( + self, + ): + hist, bin_edges = stat_clipseq_duration(self.clipseq) + print(self.media_name, "bin_edges", bin_edges) + print(self.media_name, "hist", hist) + + def to_dct(self, target_keys: list = None, ignored_keys: list = None): + raise NotImplementedError + + @property + def duration( + self, + ): + return self.clipseq.duration + + @property + def mediaid( + self, + ): + return self.meta_info.mediaid + + @property + def media_name( + self, + ): + return self.meta_info.media_name + + @property + def duration_seq_emb(self): + return self.clipseq.duration_seq_emb + + @property + def timestamp_seq_emb(self): + return self.clipseq.timestamp_seq_emb + + @property + def rela_timestamp_seq_emb(self): + return self.clipseq.rela_timestamp_seq_emb + + def get_emb(self, key, idx=None): + # TODO: 待修改为更通用的形式 + if idx is None: + idx = range(self.clip_start_idx, self.clip_end_idx + 1) + elif isinstance(idx, int): + idx += self.clip_start_idx + elif isinstance(idx, Iterable): + idx = [x + self.clip_start_idx for x in idx] + else: + raise ValueError( + f"idx only support None, int, Iterable, but given {idx},type is {type(idx)}" + ) + return self.emb.get_value(key, idx=idx) + + def get_meta_info_attr(self, key: str) -> Any: + return getattr(self.meta_info, key) + + @classmethod + def from_json_path( + cls, path: Dict, emb_path: str, media_path: str = None, **kwargs + ) -> MediaMap: + media_map = load_dct_from_file(path) + emb = H5pyMediaMapEmb(emb_path) + return cls.from_data(media_map, emb=emb, media_path=media_path, **kwargs) + + +class MediaMapSeq(Items): + def __init__(self, maps: List[MediaMap]) -> None: + super().__init__(maps) + self.maps = self.data + self.preprocess() + self.each_map_clipseq_num = [len(m.clipseq) for m in self.maps] + self.each_map_clipseq_num_cumsum = np.cumsum([0] + self.each_map_clipseq_num) + + @property + def clipseq(self): + clipseq = [] + for m in self.maps: + clipseq.extend(m.clipseq.data) + return type(self.maps[0].clipseq)(clipseq) + + @property + def stagesseq(self): + stagesseq = [] + for m in self.maps: + stagesseq.extend(m.stagesseq.data) + return type(self.maps[0].stagesseq)(stagesseq) + + @property + def frameseq(self): + frameseq = [] + for m in self.maps: + frameseq.extend(m.frameseq.data) + return type(self.maps[0].frameseq)(frameseq) + + def preprocess(self): + for m in self.maps: + m.preprocess() + + def _combine_str( + self, + attrs: List[str], + sep: str = "|", + single_maxlen: int = 10, + total_max_length: int = 60, + ) -> str: + return sep.join([str(attr)[:single_maxlen] for attr in attrs])[ + :total_max_length + ] + + def get_meta_info_attr(self, key: str, func: Callable) -> Any: + attrs = [m.get_meta_info_attr(key) for m in self.maps] + return func(attrs) + + @property + def mediaid(self) -> str: + return self.get_meta_info_attr(key="mediaid", func=self._combine_str) + + @property + def media_name(self) -> str: + return self.get_meta_info_attr(key="media_name", func=self._combine_str) + + @property + def duration(self) -> float: + return sum([m.duration for m in self.maps]) + + @property + def media_duration(self) -> float: + return self.get_meta_info_attr(key="media_duration", func=sum) + + @classmethod + def from_json_paths( + cls, + media_map_class: MediaMap, + media_paths: str, + media_map_paths: str, + emb_paths: str, + **kwargs, + ) -> MediaMapSeq: + map_seq = [ + media_map_class.from_json_path( + path=media_map_paths[i], + emb_path=emb_paths[i], + media_path=media_paths[i], + **kwargs, + ) + for i in range(len(media_map_paths)) + ] + return cls(map_seq) + + # TODO: implement mapseq stat func + def stat(self): + for m in self.maps: + m.stat() + + def _combine_embs(self, embs): + return np.concatenate(embs, axis=0) + + @property + def duration_seq_emb(self): + embs = [m.duration_seq_emb for m in self.maps] + return self._combine_embs(embs) + + @property + def timestamp_seq_emb(self): + embs = [m.timestamp_seq_emb for m in self.maps] + return self._combine_embs(embs) + + @property + def rela_timestamp_seq_emb(self): + embs = [m.rela_timestamp_seq_emb for m in self.maps] + return self._combine_embs(embs) + + def clip_idx_2_map_idx(self, idx): + target_map_idx = bisect.bisect_right(self.each_map_clipseq_num_cumsum, idx) + target_map_idx = min(max(0, target_map_idx - 1), len(self.maps) - 1) + target_map_clip_idx = idx - self.each_map_clipseq_num_cumsum[target_map_idx] + return target_map_idx, target_map_clip_idx + + def get_emb(self, key: str, idx: Union[None, int, List[int]] = None) -> np.array: + if idx is None: + embs = [m.get_emb(key, idx=idx) for m in self.maps] + else: + if not isinstance(idx, list): + idx = [idx] + embs = [] + for c_idx in idx: + target_map_idx, target_map_clip_idx = self.clip_idx_2_map_idx(c_idx) + embs.append( + self.maps[target_map_idx].get_emb(key, int(target_map_clip_idx)) + ) + if len(embs) == 1: + return embs[0] + else: + return self._combine_embs(embs) diff --git a/MuseV/MMCM/mmcm/data/media_map/media_map_process.py b/MuseV/MMCM/mmcm/data/media_map/media_map_process.py new file mode 100755 index 0000000000000000000000000000000000000000..532c4a8bf48e80e127606325386deb763296db42 --- /dev/null +++ b/MuseV/MMCM/mmcm/data/media_map/media_map_process.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +from typing import List, Union, TYPE_CHECKING +from ..clip.clip_process import ( + get_subseq_by_time, + find_time_by_stage, + +) +if TYPE_CHECKING: + from ..media_map.media_map import MediaMap + from ..clip import Clip, ClipSeq + + +__all__ =[ + "get_sub_mediamap_by_clip_idx", + "get_sub_mediamap_by_stage", + "get_sub_mediamap_by_time", +] + + +def get_sub_mediamap_by_time(media_map:MediaMap, start: int=0, end:int=1, eps=1e-2) -> MediaMap: + """获取子片段序列，同时更新media_map中的相关信息 + + Args: + media_map (MediaInfo): _description_ + start (float): 开始时间 + end (float): 结束时间 + + Returns: + _type_: _description_ + """ + if start < 1: + start = media_map.duration * start + if end is None: + end = media_map.meta_info.media_duration + elif end <= 1: + end = media_map.duration * end + media_map.meta_info.start = start + media_map.meta_info.end = end + media_map.clipseq = get_subseq_by_time( + media_map.clipseq, + start=start, + end=end, + ) + if media_map.stageseq is not None: + media_map.stageseq = get_subseq_by_time(media_map.stageseq, start=start, end=end) + return media_map + + +def get_sub_mediamap_by_clip_idx(media_map: MediaMap, start: int=None, end: int=None) -> MediaMap: + """不仅获取子片段序列，还要更新media_map中的相关信息 + + Args: + media_map (_type_): _description_ + """ + if start is None: + start = 0 + if end is None: + end = -1 + start = media_map.clipseq[start].time_start + end = media_map.clipseq[end].time_end + media_map = get_sub_mediamap_by_time(media_map=media_map, start=start, end=end) + return media_map + + +def get_sub_mediamap_by_stage(media_map: MediaMap, stages: Union[str, List[str]]) -> MediaMap: + if isinstance(stages, List): + stages = [stages] + start, _ = find_time_by_stage(media_map.stageseq, stages[0]) + _, end = find_time_by_stage(media_map.stageseq, stages[-1]) + media_map = get_sub_mediamap_by_time(media_map=media_map, start=start, end=end) + return media_map diff --git a/MuseV/MMCM/mmcm/music/__init__.py b/MuseV/MMCM/mmcm/music/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..bc39f53ceec0dc114bbd1d0bdf4f71db99599122 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/__init__.py @@ -0,0 +1,6 @@ +from .music_map.music_map import MusicMap, MusicMapSeq +from .music_map.music_clip import MusicClip, MusicClipSeq +from .music_map.meta_info import MusicMetaInfo +from .music_map.load_music_map import load_music_map + +from .utils.path_util import get_audio_path_dct diff --git a/MuseV/MMCM/mmcm/music/music_map/__init__.py b/MuseV/MMCM/mmcm/music/music_map/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/music/music_map/beat_map.py b/MuseV/MMCM/mmcm/music/music_map/beat_map.py new file mode 100755 index 0000000000000000000000000000000000000000..e671f75d8e24dcb3b62d63e573446d7fcacb17af --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/beat_map.py @@ -0,0 +1,82 @@ +import numpy as np + +from librosa.core.audio import get_duration + +from ...data.clip.clip_process import insert_endclip, insert_startclip + +from .clip_process import filter_clipseq_target_point +from .music_clip import MusicClip, MusicClipSeq + + +def beatnet2TMEType(beat: np.array, duration: float) -> MusicClipSeq: + """conver beatnet beat to tme beat type + + Args: + beat (np.array): Nx2, + 1st column is time, + 2rd is type, + 0, end point + 1, strong beat + 2,3,4 weak beat + -1 lyric + duration (float): audio time length + Returns: + MusicClipSeq: + """ + n = len(beat) + beat = np.insert(beat, 0, 0, axis=0) + beat = np.insert(beat, n + 1, [duration, 0], axis=0) + clips = [] + for i in range(n + 1): + beat_type = int(beat[i + 1, 1]) + clip = MusicClip( + time_start=beat[i, 0], # 开始时间 + duration=round(beat[i + 1, 0] - beat[i, 0], 3), # 片段持续时间 + clipid=i, # 片段序号， + timepoint_type=beat_type, + ) + clips.append(clip) + clipseq = MusicClipSeq(clips=clips) + return clipseq + + +def generate_beatseq_with_beatnet(audio_path: str) -> np.array: + """使用beatnet生成beat序列 + + Args: + audio_path (str): + Returns: + np.array: beat序列 Nx2, + 1st column is time, + 2rd is type, + 0, end point + 1, strong beat + 2,3,4 weak beat + """ + from BeatNet.BeatNet import BeatNet + + estimator = BeatNet(1, mode="offline", inference_model="DBN", plot=[], thread=False) + output = estimator.process(audio_path=audio_path) + return output + + +def generate_music_map_with_beatnet( + audio_path: str, target: list = [0, 1] +) -> MusicClipSeq: + """使用beatnet生成beat MusicClipseq + + Args: + audio_path (str): + target (list, optional): 只保留相应的拍点. Defaults to [0, 1]. + + Returns: + MusicClipSeq: 返回的beat序列 + beat: np.array, 原始的beat检测结果 + """ + output = generate_beatseq_with_beatnet(audio_path) + duration = get_duration(filename=audio_path) + clipseq = beatnet2TMEType(output, duration) + clipseq = insert_startclip(clipseq) + clipseq = insert_endclip(clipseq, duration) + clipseq = filter_clipseq_target_point(clipseq, target=target) + return clipseq, output diff --git a/MuseV/MMCM/mmcm/music/music_map/clip_process.py b/MuseV/MMCM/mmcm/music/music_map/clip_process.py new file mode 100755 index 0000000000000000000000000000000000000000..b82705af9807495c00c457c52b0744963f00d422 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/clip_process.py @@ -0,0 +1,196 @@ +from __future__ import annotations +from typing import TYPE_CHECKING, Dict, List + +import numpy as np + +from ...data.clip.clip_process import find_idx_by_time, reset_clipseq_id +from ...data.clip.clip_fusion import fuse_clips +from ...utils.util import merge_list_continuous_same_element + +if TYPE_CHECKING: + from .music_clip import MusicClip, MusicClipSeq + from .music_map import MusicMap, MusicMapSeq + + +# TODO: 待和clip操作做整合 +def music_clip_is_short(clip: MusicClip, th: float = 3) -> bool: + """判断音乐片段是否过短 + + Args: + clip (MusicClip): 待判断的音乐片段 + th (float, optional): 短篇的参数. Defaults to 3. + + Returns: + bool: 是或不是 短片段 + """ + if clip.duration < th: + return False + else: + return True + + +def music_clip_timepoint_is_target(clip: MusicClip, target: list = [-1, 1, 0]) -> bool: + """音乐片段的关键点类型是否是目标关键点 + 关键点类型暂时参考：VideoMashup/videomashup/data_structure/music_data_structure.py + Args: + clip (MusicClip): 待判断的音乐片段 + target (list, optional): 目标关键点类别. Defaults to [-1, 1, 0]. + + Returns: + bool: 是还是不是 + """ + timepoint = clip.timepoint_type + if isinstance(timepoint, int): + timepoint = {timepoint} + else: + timepoint = {int(x) for x in timepoint.split("_")} + if timepoint & set(target): + return True + else: + return False + + +def filter_clipseq_target_point( + clipseq: MusicClipSeq, target: list = [-1, 1, 0] +) -> MusicClipSeq: + """删除目标关键点之外的点，对相应的片段做融合 + + Args: + clipseq (MusicClipSeq): 待处理的音乐片段序列 + target (list, optional): 保留的目标关键点. Defaults to [-1, 1, 0]. + + Returns: + MusicClipSeq: 处理后的音乐片段序列 + """ + n_clipseq = len(clipseq) + if n_clipseq == 1: + return clipseq + newclipseq = [] + start_clip = clipseq[0] + if music_clip_timepoint_is_target(start_clip, target=target): + has_start_clip = True + else: + has_start_clip = False + i = 1 + while i <= n_clipseq - 1: + clip = clipseq[i] + start_clip_is_target = music_clip_timepoint_is_target(start_clip, target=target) + next_clip_is_target = music_clip_timepoint_is_target(clip, target=target) + # logger.debug("filter_clipseq_target_point: i={},start={}, clip={}".format(i, start_clip["timepoint_type"], clip["timepoint_type"])) + # logger.debug("start_clip_is_target: {}, next_clip_is_target {}".format(start_clip_is_target, next_clip_is_target)) + if not has_start_clip: + start_clip = clip + has_start_clip = next_clip_is_target + else: + if start_clip_is_target: + has_start_clip = True + if next_clip_is_target: + newclipseq.append(start_clip) + start_clip = clip + if i == n_clipseq - 1: + newclipseq.append(clip) + else: + start_clip = fuse_clips(start_clip, clip) + if i == n_clipseq - 1: + newclipseq.append(start_clip) + # logger.debug("filter_clipseq_target_point: fuse {}, {}".format(i, clip["timepoint_type"])) + else: + start_clip = clip + i += 1 + newclipseq = reset_clipseq_id(newclipseq) + return newclipseq + + +def merge_musicclip_into_clipseq( + clip: MusicClipSeq, clipseq: MusicClip, th: float = 1 +) -> MusicClipSeq: + """给clipseq插入一个新的音乐片段，会根据插入后片段是否过短来判断。 + + Args: + clip (MusicClipSeq): 要插入的音乐片段 + clipseq (MusicClip): 待插入的音乐片段序列 + th (float, optional): 插入后如果受影响的片段长度过短，则放弃插入. Defaults to 1. + + Returns: + MusicClipSeq: _description_ + """ + n_clipseq = len(clipseq) + clip_time = clip.time_start + idx = find_idx_by_time(clipseq, clip_time) + last_clip_time_start = clipseq[idx].time_start + next_clip_time_start = clipseq[idx].time_start + clipseq[idx].duration + last_clip_time_delta = clip_time - last_clip_time_start + clip_duration = next_clip_time_start - clip_time + # TODO: 副歌片段改变th参数来提升音符密度，暂不使用，等待音游谱面 + # TODO: 待抽离独立的业务逻辑为单独的函数 + # 只针对副歌片段插入关键点 + if clipseq[idx].text is None or ( + clipseq[idx].text is not None + and clipseq[idx].stage is not None + and "C" in clipseq[idx].stage + ): + if (last_clip_time_delta > th) and (clip_duration > th): + clip.duration = clip_duration + clipseq[idx].duration = last_clip_time_delta + clipseq.insert(idx + 1, clip) + clipseq = reset_clipseq_id(clipseq) + return clipseq + + +def merge_music_clipseq(clipseq1: MusicClipSeq, clipseq2: MusicClipSeq) -> MusicClipSeq: + """将片段序列clipseq2融合到音乐片段序列clipseq1中。融合过程也会判断新片段长度。 + + Args: + clipseq1 (MusicClipSeq): 要融合的目标音乐片段序列 + clipseq2 (MusicClipSeq): 待融合的音乐片段序列 + + Returns: + MusicClipSeq: 融合后的音乐片段序列 + """ + while len(clipseq2) > 0: + clip = clipseq2[0] + clipseq1 = merge_musicclip_into_clipseq(clip, clipseq1) + del clipseq2[0] + return clipseq1 + + +def merge_lyricseq_beatseq( + lyric_clipseq: MusicClipSeq, beat_clipseq: MusicClipSeq +) -> MusicClipSeq: + """将beat序列融合到歌词序列中 + + Args: + lyric_clipseq (MusicClipSeq): 歌词序列 + beat_clipseq (MusicClipSeq): beat序列 + + Returns: + MusicClipSeq: 融合后的音乐片段序列 + """ + newclipseq = merge_music_clipseq(lyric_clipseq, beat_clipseq) + # for i, clip in enumerate(newclipseq): + # logger.debug("i={}, time_start={}, duration={}".format(i, clip.time_start, clip.duration)) + return newclipseq + + +def get_stageseq_from_clipseq(clipseq: MusicClipSeq) -> List[Dict]: + """对clip.stage做近邻融合，返回总时间 + + Returns: + List[Dict]: 根据音乐结构进行分割的片段序列 + """ + stages = [clip.stage for clip in clipseq] + merge_stages_idx = merge_list_continuous_same_element(stages) + merge_stages = [] + for n, stages_idx in enumerate(merge_stages_idx): + dct = { + "clipid": n, + "time_start": clipseq[stages_idx["start"]].time_start, + "time_end": clipseq[stages_idx["end"]].time_end, + "stage": stages_idx["element"], + "original_clipid": list( + range(stages_idx["start"], stages_idx["end"] + 1) + ), # mss都是左闭、 右闭的方式 + } + dct["duration"] = dct["time_end"] - dct["time_start"] + merge_stages.append(dct) + return merge_stages diff --git a/MuseV/MMCM/mmcm/music/music_map/convert_type.py b/MuseV/MMCM/mmcm/music/music_map/convert_type.py new file mode 100755 index 0000000000000000000000000000000000000000..eeab5f4f847c76dcd20b907afcfd35d208b98ea2 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/convert_type.py @@ -0,0 +1,57 @@ +from ...data.clip.clip_process import ( + insert_startclip, + insert_endclip, + reset_clipseq_id, +) + +from .music_clip import MusicClip, MusicClipSeq + + +def read_osu_hitobjs(path: str) -> list: + """读取osu的音游谱面 + + Args: + path (str): 谱面低质 + + Returns: + list: 只包含HitObjects的行字符串信息 + """ + lines = [] + is_hit_info_start = False + with open(path, "r") as f: + for line in f: + if is_hit_info_start: + lines.append(line.strip()) + if "[HitObjects]" in line: + is_hit_info_start = True + return lines + + +def osu2itech(src: list, duration: float = None) -> MusicClipSeq: + """将osu的音游谱面转换为我们的目标格式 + + Args: + src (list): 音游谱面路径或者是读取的目标行字符串列表 + duration (float, optional): 歌曲长度. Defaults to None. + + Returns: + MusicClipSeq: 音乐片段序列 + """ + if isinstance(src, str): + src = read_osu_hitobjs(src) + timepoints = [float(line.split(",")[2]) for line in src] + clips = [] + for i in range(len(timepoints) - 1): + clip = MusicClip( + time_start=round(timepoints[i] / 1000, 3), + timepoint_type=0, + duration=round((timepoints[i + 1] - timepoints[i]) / 1000, 3), + clipid=i, + ) + clips.append(clip) + if len(clips) > 0: + clips = insert_startclip(clips) + if duration is not None: + clips = insert_endclip(clips, duration=duration) + clips = reset_clipseq_id(clips) + return MusicClipSeq(clips) diff --git a/MuseV/MMCM/mmcm/music/music_map/load_music_map.py b/MuseV/MMCM/mmcm/music/music_map/load_music_map.py new file mode 100755 index 0000000000000000000000000000000000000000..3d3c5eab123ad33649dd43a75efe04c508f856b1 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/load_music_map.py @@ -0,0 +1,38 @@ + + +from typing import List + +from .music_map import MusicMap, MusicMapSeq + + +def load_music_map( + music_map_paths, + music_paths, + emb_paths, + start: float=None, + end: None=None, + target_stages: List[str] = None, + **kwargs, +): + """读取视频谱面，转化成MusicInfo。当 musicinfo_path_lst 为列表时，表示多歌曲 + + Args: + musicinfo_path_lst (str or [str]): 视频谱面路径文件列表 + music_path_lst (str or [str]): 视频文件路径文件列表，须与musicinfo_path_lst等长度 + + + Returns: + MusicInfo: 视频谱面信息 + """ + dct ={ + "start": start, + "end": end, + "target_stages": target_stages, + } + if isinstance(music_map_paths, list): + music_map = MusicMapSeq.from_json_paths(media_map_class=MusicMapSeq, media_paths=music_paths, media_map_paths=music_map_paths, emb_paths=emb_paths, **dct, **kwargs) + if len(music_map) == 1: + music_map = music_map[0] + else: + music_map = MusicMap.from_json_path(path=music_map_paths, emb_path=emb_paths, media_path=music_paths, **dct, **kwargs) + return music_map \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/music/music_map/lyric_map.py b/MuseV/MMCM/mmcm/music/music_map/lyric_map.py new file mode 100755 index 0000000000000000000000000000000000000000..0d7e7bf8cdd723c640c5ddc505c1c7e8c2267dcf --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/lyric_map.py @@ -0,0 +1,149 @@ +import numpy as np +from sklearn.preprocessing import normalize, minmax_scale +from scipy.signal import savgol_filter + +# TODO：待更新音乐谱面的类信息 +from ...data.clip.clip_process import ( + complete_clipseq, + find_idx_by_clip, + insert_endclip, + insert_startclip, + reset_clipseq_id, +) + +from .music_clip import Clip, ClipSeq +from .music_clip import MusicClipSeq +from .music_map import MusicMap + + +def generate_lyric_map( + path: str, duration: float = None, gap_th: float = 2 +) -> MusicClipSeq: + """从歌词文件中生成音乐谱面 + + Args: + path (str): 歌词文件路径 + duration (float, optional): 歌词对应音频的总时长. Defaults to None. + gap_th (float, optional): 歌词中间的空白部分是否融合到上一个片段中. Defaults to 3. + + Returns: + MusicClipSeq: 以歌词文件生成的音乐谱面 + """ + from ..music_map.lyric_process import lyricfile2musicinfo + + lyric_info = lyricfile2musicinfo(path) + lyric_info = MusicMap(lyric_info, duration=duration) + clipseq = lyric_info.clipseq + lyric_info.meta_info.duration = duration + # set part of nonlyric as clip whose timepoint is 0 + for i in range(len(clipseq)): + clipseq[i].timepoint_type = -1 + lyric_info.clipseq = complete_clipseq( + clipseq=clipseq, duration=duration, gap_th=gap_th + ) + return lyric_info + + +def insert_field_2_clipseq(clipseq: ClipSeq, reference: ClipSeq, field: str) -> ClipSeq: + """将reference中每个clip的字段信息根据赋给clipseq中最近的clip + + Args: + clipseq (ClipSeq): 目标clip序列 + reference (ClipSeq): 参考clip序列 + field (str): 目标字段 + + Returns: + ClipSeq: 更新目标字段新值后的clip序列 + """ + for i, clip in enumerate(clipseq): + idx = find_idx_by_clip(reference, clip=clip) + if idx is not None: + if getattr(reference[idx], field) is not None: + clipseq[i].__dict__[field] = getattr(reference[idx], field) + return clipseq + + +def insert_rythm_2_clipseq(clipseq, reference): + """参考MSS字段的结构信息设置rythm信息。目前策略非常简单，主歌(Vx)0.25，副歌(Cx)0.75，其他为None + + Args: + clipseq (ClipSeq): 目标clip序列，设置rythm字段 + reference (ClipSeq): 参考clip序列，参考stage字段 + + Returns: + ClipSeq: 更新rythm字段新值后的clip序列 + """ + + def stage2rythm(stage): + if "V" in stage: + return 0.25 + elif "C" in stage: + return 0.75 + else: + return None + + for i, clip in enumerate(clipseq): + idx = find_idx_by_clip(reference, clip=clip) + if idx is not None: + if reference[idx].rythm is not None: + clipseq[i].rythm = stage2rythm(reference[idx].stage) + return clipseq + + +def insert_rythm_from_clip(clipseq: MusicClipSeq, beat: np.array) -> MusicClipSeq: + """给MusicClipSeq中的每个Clip新增节奏信息。目前使用 + 1. 单位时间内的歌词数量特征, 使用 min-max 归一化到 0 - 1 之间 + 2. 单位时间内的关键点数量，目前使用beatnet,使用 min-max 归一化到 0 - 1 之间 + 3. 对1、2中的特征相加，并根据歌曲结构不同进行加权 + Args: + clipseq (MusicClipSeq): 待处理的 MusicClipSeq + beat (np.array): beat检测结果，Nx2,，用于结算单位时间内的关键点数。 + 1st column is time, + 2rd is type, + 0, end point + 1, strong beat + 2,3,4 weak beat + + Returns: + MusicClipSeq: 新增 rythm 的 MusicClipSeq + """ + mss_cofficient = { + "intro": 1.0, + "bridge": 1.0, + "end": 0.8, + "VA": 1.0, + "VB": 1.0, + "CA": 1.6, + "CB": 1.6, + } + # text_num_per_second + text_num_per_second_lst = [clip.tnps for clip in clipseq if clip.tnps != 0] + common_tnps = np.min(text_num_per_second_lst) + tnps = np.array([clip.tnps if clip.tnps != 0 else common_tnps for clip in clipseq]) + tnps = minmax_scale(tnps) + # beat point _num_per_second + beat_pnps = np.zeros(len(clipseq)) + for i, clip in enumerate(clipseq): + time_start = clip.time_start + time_end = clip.time_end + target_beat = beat[(beat[:, 0] >= time_start) & (beat[:, 0] < time_end)] + beat_pnps[i] = len(target_beat) / clip.duration + beat_pnps = minmax_scale(beat_pnps) + + # cofficient + cofficients = np.array( + [ + mss_cofficient[clip.stage] + if clip.stage in mss_cofficient and clip.stage is not None + else 1.0 + for clip in clipseq + ] + ) + + rythm = cofficients * (tnps + beat_pnps) + rythm = minmax_scale(rythm) + rythm = savgol_filter(rythm, window_length=5, polyorder=3) + rythm = minmax_scale(rythm) + for i, clip in enumerate(clipseq): + clip.dynamic = rythm[i] + return clipseq diff --git a/MuseV/MMCM/mmcm/music/music_map/lyric_process.py b/MuseV/MMCM/mmcm/music/music_map/lyric_process.py new file mode 100644 index 0000000000000000000000000000000000000000..7d14fa60b4af93b11182945d11aa4e03e4bb70f4 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/lyric_process.py @@ -0,0 +1,515 @@ +from genericpath import isfile +import re +import os + +from ...text.utils.read_text import read_xml2json + + +# 一个正则表达式非常好用的网站 +# https://regex101.com/r/cW8jA6/2 + + +CHINESE_PATTERN = r"[\u4e00-\u9fff]+" +NOT_CHINESE_PATTERN = r"[^\u4e00-\u9fa5]" +ENGLISH_CHARACHTER_PATTERN = r"[a-zA-Z]+" +WORD_PATTERN = r"\w+" # equal to [a-zA-Z0-9_]. +NOT_WORD_PATTERN = r"\W+" + + +def has_target_string(lyric: str, pattern: str) -> bool: + """本句歌词是否有目标字符串 + + Args: + lyric (str): + pattern (str): 目标字符串的正则表达式式patteren + + Returns: + bool: 有没有目标字符串 + """ + matched = re.findall(pattern, lyric) + flag = len(matched) > 0 + return flag + + +def has_chinese_char(lyric: str) -> bool: + """是否有中文字符 + + Args: + lyric (str): + + Returns: + bool: 是否有中文字符 + """ + return has_target_string(lyric, CHINESE_PATTERN) + + +def has_non_chinese_char(lyric: str) -> bool: + """是否有非中文字符，参考https://git.woa.com/innovative_tech/CopyrightGroup/LyricTools/blob/master/lyric_tools/dataProcess.py#L53 + + Args: + lyric (str): + + Returns: + bool: 是否有中文字符 + """ + return has_target_string(lyric, NOT_CHINESE_PATTERN) + + +def has_english_alphabet_char(lyric: str) -> bool: + """是否有英文字母表字符 + + Args: + lyric (str): + + Returns: + bool: + """ + return has_target_string(lyric, ENGLISH_CHARACHTER_PATTERN) + + +def check_is_lyric_row(lyric: str) -> bool: + """该字符串是否是歌词 + + Args: + lyric (str): 待判断的字符串 + + Returns: + bool: 该字符串是否是歌词 + """ + is_not_lyric = [ + re.search(r"\[ti[:：]?", lyric), + re.search(r"\[ar[:：]?", lyric), + re.search(r"\[al[:：]?", lyric), + re.search(r"\[by[:：]?", lyric), + re.search(r"\[offset[:：]?", lyric), + re.search(r"词[:：]?\(\d+,\d+\)[:：]?", lyric), + re.search(r"曲[:：]?\(\d+,\d+\)[:：]?", lyric), + re.search(r"作\(\d+,\d+\)词[:：]?", lyric), + re.search(r"作\(\d+,\d+\)曲[:：]?", lyric), + re.search(r"演\(\d+,\d+\)唱[:：]?", lyric), + re.search(r"编\(\d+,\d+\)曲[:：]?", lyric), + re.search(r"吉\(\d+,\d+\)他[:：]", lyric), + re.search(r"人\(\d+,\d+\)声\(\d+,\d+\)录\(\d+,\d+\)音\(\d+,\d+\)师[:：]?", lyric), + re.search(r"人\(\d+,\d+\)声\(\d+,\d+\)录\(\d+,\d+\)音\(\d+,\d+\)棚[:：]?", lyric), + re.search(r"Vocal\s+\(\d+,\d+\)edite[:：]?", lyric), + re.search(r"混\(\d+,\d+\)音\(\d+,\d+\)/\(\d+,\d+\)母\(\d+,\d+\)带[:：]?", lyric), + re.search(r"混\(\d+,\d+\)音", lyric), + re.search(r"和\(\d+,\d+\)声\(\d+,\d+\)编\(\d+,\d+\)写[:：]?", lyric), + re.search( + r"词\(\d+,\d+\)版\(\d+,\d+\)权\(\d+,\d+\)管\(\d+,\d+\)理\(\d+,\d+\)方[:：]?", lyric + ), + re.search( + r"曲\(\d+,\d+\)版\(\d+,\d+\)权\(\d+,\d+\)管\(\d+,\d+\)理\(\d+,\d+\)方[:：]?", lyric + ), + re.search(r"联\(\d+,\d+\)合\(\d+,\d+\)出\(\d+,\d+\)品[:：]?", lyric), + re.search(r"录\(\d+,\d+\)音\(\d+,\d+\)作\(\d+,\d+\)品", lyric), + re.search( + r"录\(\d+,\d+\)音\(\d+,\d+\)作\(\d+,\d+\)品\(\d+,\d+\)监\(\d+,\d+\)制[:：]?", lyric + ), + re.search(r"制\(\d+,\d+\)作\(\d+,\d+\)人[:：]?", lyric), + re.search(r"制\(\d+,\d+\)作\(\d+,\d+\)人[:：]?", lyric), + re.search(r"不\(\d+,\d+\)得\(\d+,\d+\)翻\(\d+,\d+\)唱", lyric), + re.search(r"未\(\d+,\d+\)经\(\d+,\d+\)许\(\d+,\d+\)可", lyric), + re.search(r"酷\(\d+,\d+\)狗\(\d+,\d+\)音\(\d+,\d+\)乐", lyric), + re.search(r"[:：]", lyric), + ] + is_not_lyric = [x is not None for x in is_not_lyric] + is_not_lyric = any(is_not_lyric) + is_lyric = not is_not_lyric + return is_lyric + + +def lyric2clip(lyric: str) -> dict: + """convert a line of lyric into a clip + Clip定义可以参考 https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/media/clip.py + Args: + lyric (str): _description_ + + Returns: + dict: 转化成Clip 字典 + """ + time_str_groups = re.findall(r"\d+,\d+", lyric) + line_time_start = round(int(time_str_groups[0].split(",")[0]) / 1000, 3) + line_duration = round(int(time_str_groups[0].split(",")[-1]) / 1000, 3) + line_end_time = line_time_start + line_duration + last_word_time_start = round(int(time_str_groups[-1].split(",")[0]) / 1000, 3) + last_word_duration = round(int(time_str_groups[-1].split(",")[-1]) / 1000, 3) + last_word_end_time = last_word_time_start + last_word_duration + actual_duration = min(line_end_time, last_word_end_time) - line_time_start + lyric = re.sub(r"\[\d+,\d+\]", "", lyric) + + # by yuuhong: 把每个字的起始时间点、结束时间点、具体的字拆分出来 + words_with_timestamp = get_words_with_timestamp(lyric) + + lyric = re.sub(r"\(\d+,\d+\)", "", lyric) + dct = { + "time_start": line_time_start, + "duration": actual_duration, + "text": lyric, + "original_text": lyric, + "timepoint_type": -1, + "clips": words_with_timestamp, + } + return dct + + +# by yuuhong +# 把一句QRC中的每个字拆分出来 +# lyric示例：漫(17316,178)步(17494,174)走(17668,193)在(17861,183) (18044,0)莎(18044,153)玛(18197,159)丽(18356,176)丹(18532,200) +def get_words_with_timestamp(lyric): + words_with_timestamp = [] + elements = lyric.split(")") + for element in elements: + sub_elements = element.split("(") + if len(sub_elements) != 2: + continue + text = sub_elements[0] + timestamp = sub_elements[1] + if re.match(r"\d+,\d+", timestamp): + # 有效时间戳 + time_start_str = timestamp.split(",")[0] + time_start = round(int(time_start_str) / 1000, 3) + duration_str = timestamp.split(",")[1] + duration = round(int(duration_str) / 1000, 3) + clip = {"text": text, "time_start": time_start, "duration": duration} + words_with_timestamp.append(clip) + return words_with_timestamp + + +def lyric2clips(lyric: str, th: float = 0.75) -> list: + """将一句歌词转换为至少1个的clip。拆分主要是针对中文空格拆分，如果拆分后片段过短，也会整句处理。 + Args: + lyric (str): such as [173247,3275]去(173247,403)吗(173649,677) 配(174326,189)吗(174516,593) 这(175108,279) + th (float, optional): 后面如果拆分后片段过短，也会整句处理. Defaults to 1.0. + + Returns: + list: 歌词Clip序列 + """ + # 目前只对中文的一句歌词按照空格拆分，如果是英文空格则整句处理 + # 后面如果拆分后片段过短，也会整句处理 + if has_english_alphabet_char(lyric): + return [lyric2clip(lyric)] + splited_lyric = lyric.split(" ") + if len(splited_lyric) == 1: + return [lyric2clip(splited_lyric[0])] + line_time_str, sub_lyric = re.split(r"]", splited_lyric[0]) + line_time_groups = re.findall(r"\d+,\d+", line_time_str) + line_time_start = round(int(line_time_groups[0].split(",")[0]) / 1000, 3) + line_duration = round(int(line_time_groups[0].split(",")[-1]) / 1000, 3) + splited_lyric[0] = sub_lyric + # 歌词xml都是歌词仅跟着时间，如果有空格 空格也应该是在时间后面，但有时候空格却在字后面、在时间前，因此需要修正 + # 错误的：[173247,3275]去(173247,403)吗 (173649,677)配(174326,189)吗 (174516,593)这(175108,279) + # 错误的：[46122,2082]以(46122,213)身(46335,260)淬(46595,209)炼(46804,268)天(47072,250)地(47322,370)造(47692,341)化 (48033,172) + # 修正成：[173247,3275]去(173247,403)吗(173649,677) 配(174326,189)吗(174516,593) 这(175108,279) + for i in range(len(splited_lyric)): + if splited_lyric[i] == "": + del splited_lyric[i] + break + if splited_lyric[i][-1] != ")": + next_lyric_time_start = re.search( + r"\(\d+,\d+\)", splited_lyric[i + 1] + ).group(0) + splited_lyric[i] += next_lyric_time_start + splited_lyric[i + 1] = re.sub( + next_lyric_time_start, "", splited_lyric[i + 1] + ) + splited_lyric[i + 1] = re.sub("\(\)", "", splited_lyric[i + 1]) + lyric_text = re.sub(r"\[\d+,\d+\]", "", lyric) + lyric_text = re.sub(r"\(\d+,\d+\)", "", lyric_text) + clips = [] + has_short_clip = False + for sub_lyric in splited_lyric: + sub_lyric_groups = re.findall(r"\d+,\d+", sub_lyric) + sub_lyric_1st_word_time_start = round( + int(sub_lyric_groups[0].split(",")[0]) / 1000, 3 + ) + sub_lyric_last_word_time_start = round( + int(sub_lyric_groups[-1].split(",")[0]) / 1000, 3 + ) + sub_lyric_last_word_duration = round( + int(sub_lyric_groups[-1].split(",")[-1]) / 1000, 3 + ) + sub_lyric_last_word_time_end = ( + sub_lyric_last_word_time_start + sub_lyric_last_word_duration + ) + sub_lyric_duration = ( + sub_lyric_last_word_time_end - sub_lyric_1st_word_time_start + ) + if sub_lyric_duration <= th: + has_short_clip = True + break + sub_lyric_text = re.sub(r"\[\d+,\d+\]", "", sub_lyric) + sub_lyric_text = re.sub(r"\(\d+,\d+\)", "", sub_lyric_text) + # 使用原始lyric，而不是sub_lyric_text 主要是保留相关clip的歌词信息，便于语义连续 + dct = { + "time_start": sub_lyric_1st_word_time_start, + "duration": sub_lyric_duration, + "text": sub_lyric_text, + "original_text": lyric_text, + "timepoint_type": -1, + } + clips.append(dct) + if has_short_clip: + clips = [lyric2clip(lyric)] + return clips + + +def is_songname(lyric: str) -> bool: + """是否是歌名，歌名文本含有ti, 如[ti:霍元甲 (《霍元甲》电影主题曲)] + + Args: + lyric (str): + + Returns: + bool: + """ + return has_target_string(lyric, r"\[ti[:：]?") + + +def get_songname(lyric: str) -> str: + """获取文本中的歌名，输入必须类似[ti:霍元甲 (《霍元甲》电影主题曲)] + + Args: + lyric (str): 含有歌名的QRC文本行 + + Returns: + str: 歌名 + """ + return lyric.split("(")[0][4:-1] + + +def is_album(lyric: str) -> bool: + """是否含有专辑名，文本必须类似[al:霍元甲] + + Args: + lyric (str): _description_ + + Returns: + bool: _description_ + """ + + return has_target_string(lyric, r"\[al[:：]?") + + +def get_album(lyric: str) -> str: + """提取专辑名，文本必须类似[al:霍元甲] + + + Args: + lyric (str): 含有专辑名的QRC文本行 + + Returns: + str: 专辑名 + """ + return lyric[4:-1] + + +def is_singer(lyric: str) -> bool: + """是否有歌手名，目标文本类似 [ar:周杰伦] + + Args: + lyric (str): _description_ + + Returns: + bool: _description_ + """ + return has_target_string(lyric, r"\[ar[:：]?") + + +def get_singer(lyric: str) -> str: + """提取歌手信息，文本必须类似[ar:周杰伦] + + Args: + lyric (str): 含有歌手名的QRC文本行 + + Returns: + str: 歌手名 + """ + return lyric[4:-1] + + +def lyric2musicinfo(lyric: str) -> dict: + """convert lyric content from str into musicinfo, a dict + 参考https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/media/media_info.py#L19 + { + "meta_info": {}, + "sub_meta_info": [], + "clips": [ + clip + ] + } + + Args: + lyric (str): 来自QRC的歌词字符串 + + Returns: + musicinfo: 音乐谱面字典，https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/media/media_info.py#L19 + """ + lyrics = lyric["QrcInfos"]["LyricInfo"]["Lyric_1"]["@LyricContent"] + musicinfo = { + "meta_info": { + "mediaid": None, + "media_name": None, + "singer": None, + }, + "sub_meata_info": {}, + "clips": [], + } + # lyrics = [line.strip() for line in re.split(r"[\t\n\s+]", lyrics)] + lyrics = ["[" + line.strip() for line in re.split(r"\[", lyrics)] + next_is_title_row = False + lyric_clips = [] + for line in lyrics: + if is_songname(line): + musicinfo["meta_info"]["media_name"] = get_songname(line) + continue + if is_singer(line): + musicinfo["meta_info"]["singer"] = get_singer(line) + continue + if is_album(line): + musicinfo["meta_info"]["album"] = get_album(line) + continue + is_lyric_row = check_is_lyric_row(line) + if next_is_title_row: + next_is_title_row = False + continue + # remove tille row + if not next_is_title_row and re.search(r"\[offset[:：]", line): + next_is_title_row = True + if is_lyric_row and re.match(r"\[\d+,\d+\]", line): + lyric_clip = lyric2clip(line) + lyric_clips.append(lyric_clip) + clips = lyric2clips(line) + musicinfo["clips"].extend(clips) + musicinfo["meta_info"]["lyric"] = lyric_clips + return musicinfo + + +def lrc_timestr2time(time_str: str) -> float: + """提取lrc中的时间戳文本，类似[00:00.00]，转化成秒的浮点数 + + Args: + time_str (str): + + Returns: + float: 时间浮点数 + """ + m, s, ms = (float(x) for x in re.split(r"[:.]", time_str)) + return round((m * 60 + s + ms / 1000), 3) + + +def get_lrc_line_time(text: str, time_pattern: str) -> str: + """提取lrc中的时间字符串, 类似 \"[00:00.00]本字幕由天琴实验室独家AI字幕技术生成\" + + Args: + text (str): 输入文本 + time_pattern (str): 时间字符串正则表达式 + + Returns: + str: 符合正则表达式的时间信息文本 + """ + time_str = re.search(time_pattern, text).group(0) + return lrc_timestr2time(time_str) + + +def lrc_lyric2clip(lyric: str, time_pattern: str, duration: float) -> dict: + """将一行lrc文本字符串转化为Clip 字典 + + Args: + lyric (str): 类似 \"[00:00.00]本字幕由天琴实验室独家AI字幕技术生成\" + time_pattern (str): 时间字符串正则表达式，类似 r"\d+:\d+\.\d+" + duration (float): clip的时长信息， + + Returns: + dict: 转化后Clip + Clip定义可以参考 https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/media/clip.py + """ + time_str = get_lrc_line_time(lyric, time_pattern=time_pattern) + text = re.sub(time_pattern, "", lyric) + text = text[2:] + clip = { + "time_start": time_str, + "duration": duration, + "text": text, + "timepoint_type": -1, + } + return clip + + +def lrc2musicinfo(lyric: str, time_pattern: str = "\d+:\d+\.\d+") -> dict: + """将lrc转化为音乐谱面 + + Args: + lyric (str): lrc文本路径 + time_pattern (str, optional): lrc时间戳字符串正则表达式. Defaults to "\d+:\d+\.\d+". + + Returns: + dict: 生成的音乐谱面字典，定义可参考 https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/music/music_info.py + """ + if isinstance(lyric, str): + if os.path.isfile(lyric): + with open(lyric, "r") as f: + lyric = [line.strip() for line in f.readlines()] + return lrc2musicinfo(lyric) + else: + lyric = lyric.split("\n") + return lrc2musicinfo(lyric) + else: + musicinfo = { + "meta_info": { + "mediaid": None, + "media_name": None, + "singer": None, + }, + "sub_meata_info": {}, + "clips": [], + } + # lyrics = [line.strip() for line in re.split(r"[\t\n\s+]", lyrics)] + lyric_clips = [] + rows = len(lyric) + for i, line in enumerate(lyric): + if is_songname(line): + musicinfo["meta_info"]["media_name"] = line[4:-1] + continue + if is_singer(line): + musicinfo["meta_info"]["singer"] = line[4:-1] + continue + if is_album(line): + musicinfo["meta_info"]["album"] = line[4:-1] + continue + if len(re.findall(time_pattern, line)) > 0: + if i < rows - 1: + time_start = get_lrc_line_time(line, time_pattern=time_pattern) + next_line_time_start = get_lrc_line_time( + lyric[i + 1], time_pattern=time_pattern + ) + duration = next_line_time_start - time_start + else: + duration = 1 + clip = lrc_lyric2clip( + line, duration=duration, time_pattern=time_pattern + ) + musicinfo["clips"].append(clip) + musicinfo["meta_info"]["lyric"] = lyric_clips + return musicinfo + + +def lyricfile2musicinfo(path: str) -> dict: + """将歌词文件转化为音乐谱面，歌词文件可以是QRC的xml文件、也可以是lrc对应的lrc文件 + TODO： 待支持osu + + Args: + path (str): 歌词文件路径 + + Returns: + dict: 音乐谱面字典，定义可参考 https://git.woa.com/innovative_tech/VideoMashup/blob/master/videomashup/music/music_info.py + """ + + filename, ext = os.path.basename(path).split(".") + if ext == "xml": + lyric = read_xml2json(path) + musicinfo = lyric2musicinfo(lyric) + elif ext == "lrc": + musicinfo = lrc2musicinfo(path) + musicinfo["meta_info"]["mediaid"] = filename + return musicinfo diff --git a/MuseV/MMCM/mmcm/music/music_map/meta_info.py b/MuseV/MMCM/mmcm/music/music_map/meta_info.py new file mode 100755 index 0000000000000000000000000000000000000000..6c51a1e4cfbe63bae36129738f5ec7477e8f9594 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/meta_info.py @@ -0,0 +1,21 @@ +from __future__ import annotations + +from ...data import MetaInfo + + +class MusicMetaInfo(MetaInfo): + def __init__(self, mediaid=None, media_name=None, media_duration=None, signature=None, media_path: str = None, media_map_path: str = None, + singer=None, + lyric_path=None, + genre=None, + language=None, + start: float = None, end: float = None, ext=None, **kwargs): + super().__init__(mediaid, media_name, media_duration, signature, media_path, media_map_path, start, end, ext, **kwargs) + self.singer = singer + self.genre = genre + self.language = language + self.lyric_path = lyric_path + + @classmethod + def from_data(cls, data) -> MusicMetaInfo: + return MusicMetaInfo(**data) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/music/music_map/mss_map.py b/MuseV/MMCM/mmcm/music/music_map/mss_map.py new file mode 100755 index 0000000000000000000000000000000000000000..f904b8fbc94739a9a8bd9f4ffe52e29379135d8b --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/mss_map.py @@ -0,0 +1,185 @@ +import logging + +from .music_clip import MusicClip, MusicClipSeq +from .music_map import MusicMap +from ...data.clip.clip_process import find_idx_by_time + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def insert_mss_2_clipseq( + clipseq: MusicClipSeq, mss_clipseq: MusicClipSeq +) -> MusicClipSeq: + """将mss中的结构字段信息赋予到目标clipseq中的最近clip + + Args: + clipseq (ClipSeq): 目标clip序列 + reference (ClipSeq): 参考clip序列 + field (str): 目标字段 + + Returns: + ClipSeq: 更新目标字段新值后的clip序列 + """ + for i, clip in enumerate(clipseq): + idx = find_idx_by_time(mss_clipseq, clip.time_start) + if idx is not None: + clipseq[i].stage = mss_clipseq[idx].stage + else: + clipseq[i].stage = "unknow" + return clipseq + + +def get_mss_musicinfo(songid: str) -> MusicMap: + """通过调用media_data中的接口 获取天琴实验室的歌曲结构信息 + + Args: + songid (str): 歌词id + + Returns: + MusicMap: mss结构信息生成的音乐谱面 + """ + try: + from media_data.oi.tianqin_database import get_mss + + mss = get_mss(songid=songid) + except Exception as e: + logger.warning("get mss failed, mss={}".format(songid)) + logger.exception(e) + mss = None + mss_musicinfo = MusicMap(mss) if mss is not None else None + return mss_musicinfo + + +def merge_mss(musicinfo: MusicMap, mss: MusicMap) -> MusicMap: + """融合mss音乐谱面到目标音乐谱面 + + Args: + musicinfo (MusicMap): 目标音乐谱面 + mss (MusicMap): 待融合的mss音乐谱面 + + Returns: + MusicMap: 融合后的音乐谱面 + """ + musicinfo.meta_info.bpm = mss.meta_info.bpm + if len(mss.clipseq) > 0: + musicinfo.clipseq = insert_mss_2_clipseq(musicinfo.clipseq, mss.clipseq) + return musicinfo + + +def generate_mss_from_lyric(lyrics: list, audio_duration: float, th=8) -> MusicClipSeq: + # "intro", "VA", "CA", "bridge", "VB", "CB", "end"] + mss = [] + n_lyric = len(lyrics) + for lyric_idx, line_lyric_dct in enumerate(lyrics): + time_start = line_lyric_dct["time_start"] + duration = line_lyric_dct["duration"] + time_end = time_start + duration + # text = line_lyric_dct["text"] + if lyric_idx == 0: + sub_mss = { + "stage": "intro", + "time_start": 0, + "duration": time_start, + } + mss.append(sub_mss) + continue + if lyric_idx == n_lyric - 1: + sub_mss = { + "stage": "end", + "time_start": time_end, + "duration": audio_duration - time_end, + } + mss.append(sub_mss) + continue + + if lyrics[lyric_idx + 1]["time_start"] - time_end >= th: + sub_mss = { + "stage": "bridge", + "time_start": time_end, + "duration": lyrics[lyric_idx + 1]["time_start"] - time_end, + } + mss.append(sub_mss) + mss_lyric = [] + for sub_idx, sub_mss in enumerate(mss): + if sub_idx == len(mss) - 1: + continue + time_end = sub_mss["time_start"] + sub_mss["duration"] + next_time_start = mss[sub_idx + 1]["time_start"] + if next_time_start - time_end > 0.1: + mss_lyric.append( + { + "stage": "lyric", + "time_start": time_end, + "duration": next_time_start - time_end, + } + ) + mss.extend(mss_lyric) + mss = sorted(mss, key=lambda x: x["time_start"]) + mss = MusicClipSeq(mss) + return mss + + +def refine_mss_info_from_tianqin( + mss_info: MusicMap, lyricseq: MusicClipSeq +) -> MusicMap: + """优化天琴的歌曲结信息, + 优化前：天琴歌曲结构里面只有每句歌词和结构信息，时间前后不连续，对于整首歌去时间结构不完备。 + 优化后：增加intro,bridge,end，将相近的结构信息合并，时间前后连续，时间完备 + + Args: + mss_info (MusicMap): 天琴歌曲结构 + lyricseq (ClipSeq): 原始歌曲信息，用于计算Intro,bridge,end。其实也可以从mss_info中获取。 + + Returns: + MusicMap: 优化后的歌曲结构信息 + """ + lyric_mss_clipseq = generate_mss_from_lyric( + lyricseq, audio_duration=mss_info.meta_info.duration + ) + new_mss_clipseq = [] + # lyric_mss_dct = lyric_mss_clipseq.to_dct() + # mss_dct = mss_info.clipseq.to_dct() + for l_clip_idx, lyric_clip in enumerate(lyric_mss_clipseq): + if lyric_clip.stage != "lyric": + new_mss_clipseq.append(lyric_clip) + else: + new_clip_time_start = lyric_clip.time_start + last_stage = "ANewClipStart" + for clip_idx, clip in enumerate(mss_info.clipseq): + if clip.time_start < new_clip_time_start: + continue + if ( + clip.time_start >= lyric_mss_clipseq[l_clip_idx + 1].time_start + or clip_idx == len(mss_info.clipseq) - 1 + ): + if clip.time_start >= lyric_mss_clipseq[l_clip_idx + 1].time_start: + stage = last_stage + # 像偶阵雨这首歌最后一个歌词段落 只有一句歌词 + if clip_idx == len(mss_info.clipseq) - 1: + stage = clip.stage + new_clip_time_end = lyric_mss_clipseq[l_clip_idx + 1].time_start + new_stage_clip = { + "time_start": new_clip_time_start, + "duration": new_clip_time_end - new_clip_time_start, + "stage": stage, + } + new_mss_clipseq.append(MusicClip(**new_stage_clip)) + new_clip_time_start = new_clip_time_end + last_stage = clip.stage + break + if clip.stage != last_stage: + if last_stage == "ANewClipStart": + last_stage = clip.stage + continue + new_clip_time_end = mss_info.clipseq[clip_idx].time_start + new_stage_clip = { + "time_start": new_clip_time_start, + "duration": new_clip_time_end - new_clip_time_start, + "stage": last_stage, + } + new_mss_clipseq.append(MusicClip(**new_stage_clip)) + new_clip_time_start = new_clip_time_end + last_stage = clip.stage + new_mss_clipseq = MusicClipSeq(sorted(new_mss_clipseq, key=lambda x: x.time_start)) + mss_info.clipseq = new_mss_clipseq + return mss_info diff --git a/MuseV/MMCM/mmcm/music/music_map/music_clip.py b/MuseV/MMCM/mmcm/music/music_map/music_clip.py new file mode 100755 index 0000000000000000000000000000000000000000..5e473e405b8451dc056e32617871b7e0d8261108 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/music_clip.py @@ -0,0 +1,83 @@ +from __future__ import annotations +from typing import Dict, List + +from ...data.clip import Clip, ClipSeq + + +class MusicClip(Clip): + def __init__(self, time_start: float, duration: float, clipid: int = None, media_type: str = None, mediaid: str = None, timepoint_type: str = None, text: str = None, stage: str = None, path: str = None, duration_num: int = None, similar_clipseq: MatchedClipIds = None, dynamic: float = None, **kwargs): + super().__init__(time_start, duration, clipid, media_type, mediaid, timepoint_type, text, stage, path, duration_num, similar_clipseq, dynamic, **kwargs) + + @property + def text_num(self): + return self._cal_text_num() + + @property + def original_text_num(self): + return self._cal_text_num(text_mode=1) + + def _cal_text_num(self, text_mode: int = 0) -> int: + """计算 文本 字的数量 + + Args: + text_mode (int, optional): 0选text， 其他选original_text. Defaults to 0. + + Returns: + int: _description_ + """ + if text_mode == 0: + text = self.text + else: + text = self.original_text + if text is None: + n_text = 0 + else: + text = text.strip().split(" ") + n_text = len(text) + return n_text + + @property + def text_num_per_second(self): + """单位时间内的text数量""" + return self._cal_text_num_per_second(mode=0) + + @property + def original_text_num_per_second(self): + """单位时间内的original_text数量""" + return self._cal_text_num_per_second(mode=1) + + @property + def tnps(self): + """单位时间内的text数量""" + return self.text_num_per_second + + @property + def original_tnps(self): + """单位时间内的original_text数量""" + return self.original_text_num_per_second + + def _cal_text_num_per_second(self, mode=0): + """计算单位时间内的文本数量""" + text_num = self.text_num if mode == 0 else self.original_text_num + return text_num / self.duration + + @classmethod + def from_data(cls, data: Dict): + return MusicClip(**data) + + +class MusicClipSeq(ClipSeq): + + def __init__(self, items: List[Clip] = None): + super().__init__(items) + self.clipseq = self.data + + @classmethod + def from_data(cls, clipseq: List[Dict]) -> MusicClipSeq: + new_clipseq = [] + for clip in clipseq: + video_clip = MusicClip.from_data(clip) + new_clipseq.append(video_clip) + video_clipseq = MusicClipSeq(new_clipseq) + return video_clipseq + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/music/music_map/music_map.py b/MuseV/MMCM/mmcm/music/music_map/music_map.py new file mode 100755 index 0000000000000000000000000000000000000000..12b4f7b94abf9ee738209772a9db9c8a46745cde --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/music_map.py @@ -0,0 +1,140 @@ +from __future__ import annotations +from typing import List, Dict + +from moviepy.editor import concatenate_audioclips, AudioClip, AudioFileClip + +from ...data import MediaMap, MediaMapEmb, MetaInfo, MediaMapSeq +from ...data.clip.clip_process import find_time_by_stage +from ...data.emb.h5py_emb import H5pyMediaMapEmb +from ...utils.util import load_dct_from_file + +from .clip_process import get_stageseq_from_clipseq +from .music_clip import MusicClip, MusicClipSeq +from .meta_info import MusicMetaInfo + + +class MusicMap(MediaMap): + def __init__( + self, + meta_info: MetaInfo, + clipseq: MusicClipSeq, + lyricseq: MusicClipSeq = None, + stageseq: MusicClipSeq = None, + frameseq: MusicClipSeq = None, + emb: MediaMapEmb = None, + **kwargs, + ): + self.lyricseq = lyricseq + super().__init__(meta_info, clipseq, stageseq, frameseq, emb, **kwargs) + if self.stageseq is None: + self.stageseq = MusicClipSeq.from_data( + get_stageseq_from_clipseq(self.clipseq) + ) + self.stageseq.preprocess() + + def preprocess(self): + if ( + hasattr(self.meta_info, "target_stages") + and self.meta_info.target_stages is not None + ): + self.set_start_end_by_target_stages() + super().preprocess() + self.spread_metainfo_2_clip( + target_keys=[ + "media_path", + "media_map_path", + "emb_path", + "media_duration", + "mediaid", + "media_name", + "emb", + ] + ) + + def set_start_end_by_target_stages(self): + target_stages = self.meta_info.target_stages + if not isinstance(target_stages, List): + target_stages = [target_stages] + start, _ = find_time_by_stage(self.stageseq, target_stages[0]) + _, end = find_time_by_stage(self.stageseq, target_stages[-1]) + self.meta_info.start = start + self.meta_info.end = end + + @property + def audio_clip(self) -> AudioFileClip: + """读取实际ClipSeq中的音频 + + Returns: + AudioClip: Moviepy中的audio_clip + """ + audio_clip = AudioFileClip(self.meta_info.media_path) + audio_clip = audio_clip.subclip(self.meta_info.start, self.meta_info.end) + return audio_clip + + @classmethod + def from_json_path( + cls, path: Dict, emb_path: str, media_path: str = None, **kwargs + ) -> MusicMap: + media_map = load_dct_from_file(path) + emb = H5pyMediaMapEmb(emb_path) + return cls.from_data(media_map, emb=emb, media_path=media_path, **kwargs) + + @classmethod + def from_data( + cls, data: Dict, emb: H5pyMediaMapEmb, media_path: str = None, **kwargs + ) -> MusicMap: + meta_info = MusicMetaInfo.from_data(data.get("meta_info", {})) + meta_info.media_path = media_path + clipseq = MusicClipSeq.from_data(data.get("clipseq", [])) + stageseq = MusicClipSeq.from_data(data.get("stageseq", [])) + lyricseq = MusicClipSeq.from_data(data.get("lyricseq", [])) + target_keys = ["meta_info", "clipseq", "frameseq", "stageseq", "lyricseq"] + dct = {k: data[k] for k in data.keys() if k not in target_keys} + dct.update(**kwargs) + video_map = MusicMap( + meta_info=meta_info, + clipseq=clipseq, + stageseq=stageseq, + lyricseq=lyricseq, + emb=emb, + **dct, + ) + return video_map + + def to_dct( + self, target_keys: List[str] = None, ignored_keys: List[str] = None + ) -> Dict: + dct = {} + dct["meta_info"] = self.meta_info.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + dct["clipseq"] = self.clipseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + if self.frameseq is not None: + dct["frameseq"] = self.frameseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + else: + dct["frameseq"] = None + if self.stageseq is not None: + dct["stageseq"] = self.stageseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + else: + dct["stageseq"] = None + dct["lyricseq"] = self.lyricseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + return dct + + +class MusicMapSeq(MediaMapSeq): + def __init__(self, maps: List[MusicMap]) -> None: + super().__init__(maps) + + @property + def audio_clip(self) -> AudioFileClip: + audio_clip_lst = [m.audi_clip for m in self.maps] + audio_clip = concatenate_audioclips(audio_clip_lst) + return audio_clip diff --git a/MuseV/MMCM/mmcm/music/music_map/music_map_demp.py b/MuseV/MMCM/mmcm/music/music_map/music_map_demp.py new file mode 100755 index 0000000000000000000000000000000000000000..d1467df207d34fe26bfde1edc65517fc83e12952 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/music_map/music_map_demp.py @@ -0,0 +1,58 @@ +from moviepy.editor import ( + ColorClip, + concatenate_videoclips, + AudioFileClip, + CompositeVideoClip, +) + +from ...vision.video_map.video_lyric import render_lyric2video +from ...vision.video_map.video_writer import write_videoclip +from .music_map import MusicMap + + +def generate_music_map_videodemo( + music_map: MusicMap, + path: str, + audio_path: str, + render_lyric: bool = True, + width: int = 360, + height: int = 240, + fps: int = 25, + n_thread: int = 8, + colors: list = [[51, 161, 201], [46, 139, 87]], +) -> None: + """输入音乐谱面，生成对应的转场视频Demo，视频内容只是简单的颜色切换 + + Args: + music_map (MusicInfo): 待可视化的音乐谱面 + path (str): 可视化视频的存储路径 + audio_path (str): 音乐谱面对应的音频路径 + render_lyric (bool, optional): 是否渲染歌词，歌词在音乐谱面中. Defaults to True. + width (int, optional): 可视化视频的宽. Defaults to 360. + height (int, optional): 可视化视频的高. Defaults to 240. + fps (int, optional): 可视化视频的fps. Defaults to 25. + n_thread (int, optional): 可视化视频的写入线程数. Defaults to 8. + colors (list, optional): 可视化的视频颜色. Defaults to [[51, 161, 201], [46, 139, 87]]. + """ + audio_clip = AudioFileClip(audio_path) + video_clips = [] + size = (width, height) + for i, clip in enumerate(music_map.clipseq): + clip = ColorClip( + size=size, color=colors[i % len(colors)], duration=clip.duration + ) + video_clips.append(clip) + video_clips = concatenate_videoclips(video_clips, method="compose") + if render_lyric: + video_clips = render_lyric2video( + videoclip=video_clips, + lyric=music_map, + lyric_info_type="music_map", + ) + video_clips = video_clips.set_audio(audio_clip) + write_videoclip( + video_clips, + path=path, + fps=fps, + n_thread=n_thread, + ) diff --git a/MuseV/MMCM/mmcm/music/utils/__init__.py b/MuseV/MMCM/mmcm/music/utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/music/utils/path_util.py b/MuseV/MMCM/mmcm/music/utils/path_util.py new file mode 100755 index 0000000000000000000000000000000000000000..a2f0f9d332b0d1755020dde125ff89be8048b0f2 --- /dev/null +++ b/MuseV/MMCM/mmcm/music/utils/path_util.py @@ -0,0 +1,9 @@ +import os +from typing import Dict, Tuple + +from ...utils.path_util import get_dir_file_map + + +def get_audio_path_dct(path, exts=["mp3", "flac", "wav"]) -> Dict[str, str]: + """遍历目标文件夹及子文件夹下所有音频文件，生成字典。""" + return get_dir_file_map(path, exts=exts) diff --git a/MuseV/MMCM/mmcm/t2p/.gitignore b/MuseV/MMCM/mmcm/t2p/.gitignore new file mode 100755 index 0000000000000000000000000000000000000000..5f170f04619c1b0a59e2ead7dc65455983fcb2c0 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/.gitignore @@ -0,0 +1,158 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +.vscode +dataset/dataset_TM_train_cb1_temp.py +train_gpt_cnn_temp.py +train_gpt_cnn_mask.py +start.sh +start_eval.sh +config.json +output_GPT_Final +output_vqfinal +output_transformer +glove +checkpoints +dataset/HumanML3D +dataset/KIT-ML +output +matrix_multi.py +body_models +render_final_diffuse.py +render_final_mdm.py +pretrained +MDM +Motiondiffusion +Visualize_temp.py +new.sh +T2M_render +render_final_t2m.py + +pose \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/GPT_eval_multi.py b/MuseV/MMCM/mmcm/t2p/GPT_eval_multi.py new file mode 100755 index 0000000000000000000000000000000000000000..f757367114e8adb4676681367351defddd08fc9d --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/GPT_eval_multi.py @@ -0,0 +1,121 @@ +import os +import torch +import numpy as np +from torch.utils.tensorboard import SummaryWriter +import json +import clip + +import options.option_transformer as option_trans +import models.vqvae as vqvae +import utils.utils_model as utils_model +import utils.eval_trans as eval_trans +from dataset import dataset_TM_eval +import models.t2m_trans as trans +from options.get_eval_option import get_opt +from models.evaluator_wrapper import EvaluatorModelWrapper +import warnings +warnings.filterwarnings('ignore') + +##### ---- Exp dirs ---- ##### +args = option_trans.get_args_parser() +torch.manual_seed(args.seed) + +args.out_dir = os.path.join(args.out_dir, f'{args.exp_name}') +os.makedirs(args.out_dir, exist_ok = True) + +##### ---- Logger ---- ##### +logger = utils_model.get_logger(args.out_dir) +writer = SummaryWriter(args.out_dir) +logger.info(json.dumps(vars(args), indent=4, sort_keys=True)) + +from utils.word_vectorizer import WordVectorizer +w_vectorizer = WordVectorizer('./glove', 'our_vab') +val_loader = dataset_TM_eval.DATALoader(args.dataname, True, 32, w_vectorizer) + +dataset_opt_path = 'checkpoints/kit/Comp_v6_KLD005/opt.txt' if args.dataname == 'kit' else 'checkpoints/t2m/Comp_v6_KLD005/opt.txt' + +wrapper_opt = get_opt(dataset_opt_path, torch.device('cuda')) +eval_wrapper = EvaluatorModelWrapper(wrapper_opt) + +##### ---- Network ---- ##### + +## load clip model and datasets +clip_model, clip_preprocess = clip.load("ViT-B/32", device=torch.device('cuda'), jit=False) # Must set jit=False for training +clip.model.convert_weights(clip_model) # Actually this line is unnecessary since clip by default already on float16 +clip_model.eval() +for p in clip_model.parameters(): + p.requires_grad = False + +net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers + args.nb_code, + args.code_dim, + args.output_emb_width, + args.down_t, + args.stride_t, + args.width, + args.depth, + args.dilation_growth_rate) + + +trans_encoder = trans.Text2Motion_Transformer(num_vq=args.nb_code, + embed_dim=args.embed_dim_gpt, + clip_dim=args.clip_dim, + block_size=args.block_size, + num_layers=args.num_layers, + n_head=args.n_head_gpt, + drop_out_rate=args.drop_out_rate, + fc_rate=args.ff_rate) + + +print ('loading checkpoint from {}'.format(args.resume_pth)) +ckpt = torch.load(args.resume_pth, map_location='cpu') +net.load_state_dict(ckpt['net'], strict=True) +net.eval() +net.cuda() + +if args.resume_trans is not None: + print ('loading transformer checkpoint from {}'.format(args.resume_trans)) + ckpt = torch.load(args.resume_trans, map_location='cpu') + trans_encoder.load_state_dict(ckpt['trans'], strict=True) +trans_encoder.train() +trans_encoder.cuda() + + +fid = [] +div = [] +top1 = [] +top2 = [] +top3 = [] +matching = [] +multi = [] +repeat_time = 20 + + +for i in range(repeat_time): + best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, best_multi, writer, logger = eval_trans.evaluation_transformer_test(args.out_dir, val_loader, net, trans_encoder, logger, writer, 0, best_fid=1000, best_iter=0, best_div=100, best_top1=0, best_top2=0, best_top3=0, best_matching=100, best_multi=0, clip_model=clip_model, eval_wrapper=eval_wrapper, draw=False, savegif=False, save=False, savenpy=(i==0)) + fid.append(best_fid) + div.append(best_div) + top1.append(best_top1) + top2.append(best_top2) + top3.append(best_top3) + matching.append(best_matching) + multi.append(best_multi) + +print('final result:') +print('fid: ', sum(fid)/repeat_time) +print('div: ', sum(div)/repeat_time) +print('top1: ', sum(top1)/repeat_time) +print('top2: ', sum(top2)/repeat_time) +print('top3: ', sum(top3)/repeat_time) +print('matching: ', sum(matching)/repeat_time) +print('multi: ', sum(multi)/repeat_time) + +fid = np.array(fid) +div = np.array(div) +top1 = np.array(top1) +top2 = np.array(top2) +top3 = np.array(top3) +matching = np.array(matching) +multi = np.array(multi) +msg_final = f"FID. {np.mean(fid):.3f}, conf. {np.std(fid)*1.96/np.sqrt(repeat_time):.3f}, Diversity. {np.mean(div):.3f}, conf. {np.std(div)*1.96/np.sqrt(repeat_time):.3f}, TOP1. {np.mean(top1):.3f}, conf. {np.std(top1)*1.96/np.sqrt(repeat_time):.3f}, TOP2. {np.mean(top2):.3f}, conf. {np.std(top2)*1.96/np.sqrt(repeat_time):.3f}, TOP3. {np.mean(top3):.3f}, conf. {np.std(top3)*1.96/np.sqrt(repeat_time):.3f}, Matching. {np.mean(matching):.3f}, conf. {np.std(matching)*1.96/np.sqrt(repeat_time):.3f}, Multi. {np.mean(multi):.3f}, conf. {np.std(multi)*1.96/np.sqrt(repeat_time):.3f}" +logger.info(msg_final) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/LICENSE b/MuseV/MMCM/mmcm/t2p/LICENSE new file mode 100755 index 0000000000000000000000000000000000000000..e07bc45f04128512bc8da2c688e8683efb93219f --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2023 tencent + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/MuseV/MMCM/mmcm/t2p/README.md b/MuseV/MMCM/mmcm/t2p/README.md new file mode 100755 index 0000000000000000000000000000000000000000..14d1c5d12a612039cf8043f338680be2b6c11b65 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/README.md @@ -0,0 +1,329 @@ +# (CVPR 2023) T2M-GPT +Pytorch implementation of paper "T2M-GPT: Generating Human Motion from Textual Descriptions with Discrete Representations" + + +[[Project Page]](https://mael-zys.github.io/T2M-GPT/) [[Paper]](https://arxiv.org/abs/2301.06052) [[Notebook Demo]](https://colab.research.google.com/drive/1Vy69w2q2d-Hg19F-KibqG0FRdpSj3L4O?usp=sharing) [[HuggingFace]](https://huggingface.co/vumichien/T2M-GPT) [[Space Demo]](https://huggingface.co/spaces/vumichien/generate_human_motion) + + +

+teaser +

+ +If our project is helpful for your research, please consider citing : +``` +@inproceedings{zhang2023generating, + title={T2M-GPT: Generating Human Motion from Textual Descriptions with Discrete Representations}, + author={Zhang, Jianrong and Zhang, Yangsong and Cun, Xiaodong and Huang, Shaoli and Zhang, Yong and Zhao, Hongwei and Lu, Hongtao and Shen, Xi}, + booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)}, + year={2023}, +} +``` + + +## Table of Content +* [1. Visual Results](#1-visual-results) +* [2. Installation](#2-installation) +* [3. Quick Start](#3-quick-start) +* [4. Train](#4-train) +* [5. Evaluation](#5-evaluation) +* [6. SMPL Mesh Rendering](#6-smpl-mesh-rendering) +* [7. Acknowledgement](#7-acknowledgement) +* [8. ChangLog](#8-changlog) + + + + +## 1. Visual Results (More results can be found in our [project page](https://mael-zys.github.io/T2M-GPT/)) + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Text: a man steps forward and does a handstand.
GTT2M MDM MotionDiffuse Ours
gifgifgifgifgif
Text: A man rises from the ground, walks in a circle and sits back down on the ground.
GTT2M MDM MotionDiffuse Ours
gifgifgifgifgif
+

+ +## 2. Installation + +### 2.1. Environment + + +Our model can be learnt in a **single GPU V100-32G** + +```bash +conda env create -f environment.yml +conda activate T2M-GPT +``` + +The code was tested on Python 3.8 and PyTorch 1.8.1. + + +### 2.2. Dependencies + +```bash +bash dataset/prepare/download_glove.sh +``` + + +### 2.3. Datasets + + +We are using two 3D human motion-language dataset: HumanML3D and KIT-ML. For both datasets, you could find the details as well as download link [[here]](https://github.com/EricGuo5513/HumanML3D). + +Take HumanML3D for an example, the file directory should look like this: +``` +./dataset/HumanML3D/ +├── new_joint_vecs/ +├── texts/ +├── Mean.npy # same as in [HumanML3D](https://github.com/EricGuo5513/HumanML3D) +├── Std.npy # same as in [HumanML3D](https://github.com/EricGuo5513/HumanML3D) +├── train.txt +├── val.txt +├── test.txt +├── train_val.txt +└── all.txt +``` + + +### 2.4. Motion & text feature extractors: + +We use the same extractors provided by [t2m](https://github.com/EricGuo5513/text-to-motion) to evaluate our generated motions. Please download the extractors. + +```bash +bash dataset/prepare/download_extractor.sh +``` + +### 2.5. Pre-trained models + +The pretrained model files will be stored in the 'pretrained' folder: +```bash +bash dataset/prepare/download_model.sh +``` + + +### 2.6. Render SMPL mesh (optional) + +If you want to render the generated motion, you need to install: + +```bash +sudo sh dataset/prepare/download_smpl.sh +conda install -c menpo osmesa +conda install h5py +conda install -c conda-forge shapely pyrender trimesh mapbox_earcut +``` + + + +## 3. Quick Start + +A quick start guide of how to use our code is available in [demo.ipynb](https://colab.research.google.com/drive/1Vy69w2q2d-Hg19F-KibqG0FRdpSj3L4O?usp=sharing) + +

+demo +

+ + +## 4. Train + +Note that, for kit dataset, just need to set '--dataname kit'. + +### 4.1. VQ-VAE + +The results are saved in the folder output. + +
+ +VQ training + + +```bash +python3 train_vq.py \ +--batch-size 256 \ +--lr 2e-4 \ +--total-iter 300000 \ +--lr-scheduler 200000 \ +--nb-code 512 \ +--down-t 2 \ +--depth 3 \ +--dilation-growth-rate 3 \ +--out-dir output \ +--dataname t2m \ +--vq-act relu \ +--quantizer ema_reset \ +--loss-vel 0.5 \ +--recons-loss l1_smooth \ +--exp-name VQVAE +``` + +
+ +### 4.2. GPT + +The results are saved in the folder output. + +
+ +GPT training + + +```bash +python3 train_t2m_trans.py \ +--exp-name GPT \ +--batch-size 128 \ +--num-layers 9 \ +--embed-dim-gpt 1024 \ +--nb-code 512 \ +--n-head-gpt 16 \ +--block-size 51 \ +--ff-rate 4 \ +--drop-out-rate 0.1 \ +--resume-pth output/VQVAE/net_last.pth \ +--vq-name VQVAE \ +--out-dir output \ +--total-iter 300000 \ +--lr-scheduler 150000 \ +--lr 0.0001 \ +--dataname t2m \ +--down-t 2 \ +--depth 3 \ +--quantizer ema_reset \ +--eval-iter 10000 \ +--pkeep 0.5 \ +--dilation-growth-rate 3 \ +--vq-act relu +``` + +
+ +## 5. Evaluation + +### 5.1. VQ-VAE +
+ +VQ eval + + +```bash +python3 VQ_eval.py \ +--batch-size 256 \ +--lr 2e-4 \ +--total-iter 300000 \ +--lr-scheduler 200000 \ +--nb-code 512 \ +--down-t 2 \ +--depth 3 \ +--dilation-growth-rate 3 \ +--out-dir output \ +--dataname t2m \ +--vq-act relu \ +--quantizer ema_reset \ +--loss-vel 0.5 \ +--recons-loss l1_smooth \ +--exp-name TEST_VQVAE \ +--resume-pth output/VQVAE/net_last.pth +``` + +
+ +### 5.2. GPT + +
+ +GPT eval + + +Follow the evaluation setting of [text-to-motion](https://github.com/EricGuo5513/text-to-motion), we evaluate our model 20 times and report the average result. Due to the multimodality part where we should generate 30 motions from the same text, the evaluation takes a long time. + +```bash +python3 GPT_eval_multi.py \ +--exp-name TEST_GPT \ +--batch-size 128 \ +--num-layers 9 \ +--embed-dim-gpt 1024 \ +--nb-code 512 \ +--n-head-gpt 16 \ +--block-size 51 \ +--ff-rate 4 \ +--drop-out-rate 0.1 \ +--resume-pth output/VQVAE/net_last.pth \ +--vq-name VQVAE \ +--out-dir output \ +--total-iter 300000 \ +--lr-scheduler 150000 \ +--lr 0.0001 \ +--dataname t2m \ +--down-t 2 \ +--depth 3 \ +--quantizer ema_reset \ +--eval-iter 10000 \ +--pkeep 0.5 \ +--dilation-growth-rate 3 \ +--vq-act relu \ +--resume-trans output/GPT/net_best_fid.pth +``` + +
+ + +## 6. SMPL Mesh Rendering + +
+ +SMPL Mesh Rendering + + +You should input the npy folder address and the motion names. Here is an example: + +```bash +python3 render_final.py --filedir output/TEST_GPT/ --motion-list 000019 005485 +``` + +
+ +### 7. Acknowledgement + +We appreciate helps from : + +* public code like [text-to-motion](https://github.com/EricGuo5513/text-to-motion), [TM2T](https://github.com/EricGuo5513/TM2T), [MDM](https://github.com/GuyTevet/motion-diffusion-model), [MotionDiffuse](https://github.com/mingyuan-zhang/MotionDiffuse) etc. +* Mathis Petrovich, Yuming Du, Yingyi Chen, Dexiong Chen and Xuelin Chen for inspiring discussions and valuable feedback. +* Minh Chien Vu for the hugging face space demo. + +### 8. ChangLog + +* 2023/02/19 add the hugging face space demo for both skelton and SMPL mesh visualization. diff --git a/MuseV/MMCM/mmcm/t2p/VQ_eval.py b/MuseV/MMCM/mmcm/t2p/VQ_eval.py new file mode 100755 index 0000000000000000000000000000000000000000..f1b7f269e344f730797eba13a45c9672f323b9f5 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/VQ_eval.py @@ -0,0 +1,95 @@ +import os +import json + +import torch +from torch.utils.tensorboard import SummaryWriter +import numpy as np +import models.vqvae as vqvae +import options.option_vq as option_vq +import utils.utils_model as utils_model +from dataset import dataset_TM_eval +import utils.eval_trans as eval_trans +from options.get_eval_option import get_opt +from models.evaluator_wrapper import EvaluatorModelWrapper +import warnings +warnings.filterwarnings('ignore') +import numpy as np +##### ---- Exp dirs ---- ##### +args = option_vq.get_args_parser() +torch.manual_seed(args.seed) + +args.out_dir = os.path.join(args.out_dir, f'{args.exp_name}') +os.makedirs(args.out_dir, exist_ok = True) + +##### ---- Logger ---- ##### +logger = utils_model.get_logger(args.out_dir) +writer = SummaryWriter(args.out_dir) +logger.info(json.dumps(vars(args), indent=4, sort_keys=True)) + + +from utils.word_vectorizer import WordVectorizer +w_vectorizer = WordVectorizer('./glove', 'our_vab') + + +dataset_opt_path = 'checkpoints/kit/Comp_v6_KLD005/opt.txt' if args.dataname == 'kit' else 'checkpoints/t2m/Comp_v6_KLD005/opt.txt' + +wrapper_opt = get_opt(dataset_opt_path, torch.device('cuda')) +eval_wrapper = EvaluatorModelWrapper(wrapper_opt) + + +##### ---- Dataloader ---- ##### +args.nb_joints = 21 if args.dataname == 'kit' else 22 + +val_loader = dataset_TM_eval.DATALoader(args.dataname, True, 32, w_vectorizer, unit_length=2**args.down_t) + +##### ---- Network ---- ##### +net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers + args.nb_code, + args.code_dim, + args.output_emb_width, + args.down_t, + args.stride_t, + args.width, + args.depth, + args.dilation_growth_rate, + args.vq_act, + args.vq_norm) + +if args.resume_pth : + logger.info('loading checkpoint from {}'.format(args.resume_pth)) + ckpt = torch.load(args.resume_pth, map_location='cpu') + net.load_state_dict(ckpt['net'], strict=True) +net.train() +net.cuda() + +fid = [] +div = [] +top1 = [] +top2 = [] +top3 = [] +matching = [] +repeat_time = 20 +for i in range(repeat_time): + best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger = eval_trans.evaluation_vqvae(args.out_dir, val_loader, net, logger, writer, 0, best_fid=1000, best_iter=0, best_div=100, best_top1=0, best_top2=0, best_top3=0, best_matching=100, eval_wrapper=eval_wrapper, draw=False, save=False, savenpy=(i==0)) + fid.append(best_fid) + div.append(best_div) + top1.append(best_top1) + top2.append(best_top2) + top3.append(best_top3) + matching.append(best_matching) +print('final result:') +print('fid: ', sum(fid)/repeat_time) +print('div: ', sum(div)/repeat_time) +print('top1: ', sum(top1)/repeat_time) +print('top2: ', sum(top2)/repeat_time) +print('top3: ', sum(top3)/repeat_time) +print('matching: ', sum(matching)/repeat_time) + +fid = np.array(fid) +div = np.array(div) +top1 = np.array(top1) +top2 = np.array(top2) +top3 = np.array(top3) +matching = np.array(matching) +msg_final = f"FID. {np.mean(fid):.3f}, conf. {np.std(fid)*1.96/np.sqrt(repeat_time):.3f}, Diversity. {np.mean(div):.3f}, conf. {np.std(div)*1.96/np.sqrt(repeat_time):.3f}, TOP1. {np.mean(top1):.3f}, conf. {np.std(top1)*1.96/np.sqrt(repeat_time):.3f}, TOP2. {np.mean(top2):.3f}, conf. {np.std(top2)*1.96/np.sqrt(repeat_time):.3f}, TOP3. {np.mean(top3):.3f}, conf. {np.std(top3)*1.96/np.sqrt(repeat_time):.3f}, Matching. {np.mean(matching):.3f}, conf. {np.std(matching)*1.96/np.sqrt(repeat_time):.3f}" +logger.info(msg_final) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/__init__.py b/MuseV/MMCM/mmcm/t2p/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_eval.py b/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..576a53b7dabd8095bed59dcc86199e30f2798838 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_eval.py @@ -0,0 +1,217 @@ +import torch +from torch.utils import data +import numpy as np +from os.path import join as pjoin +import random +import codecs as cs +from tqdm import tqdm + +import utils.paramUtil as paramUtil +from torch.utils.data._utils.collate import default_collate + + +def collate_fn(batch): + batch.sort(key=lambda x: x[3], reverse=True) + return default_collate(batch) + + +'''For use of training text-2-motion generative model''' +class Text2MotionDataset(data.Dataset): + def __init__(self, dataset_name, is_test, w_vectorizer, feat_bias = 5, max_text_len = 20, unit_length = 4): + + self.max_length = 20 + self.pointer = 0 + self.dataset_name = dataset_name + self.is_test = is_test + self.max_text_len = max_text_len + self.unit_length = unit_length + self.w_vectorizer = w_vectorizer + if dataset_name == 't2m': + self.data_root = './dataset/HumanML3D' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 22 + radius = 4 + fps = 20 + self.max_motion_length = 196 + dim_pose = 263 + kinematic_chain = paramUtil.t2m_kinematic_chain + self.meta_dir = 'checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + elif dataset_name == 'kit': + self.data_root = './dataset/KIT-ML' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 21 + radius = 240 * 8 + fps = 12.5 + dim_pose = 251 + self.max_motion_length = 196 + kinematic_chain = paramUtil.kit_kinematic_chain + self.meta_dir = 'checkpoints/kit/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + + mean = np.load(pjoin(self.meta_dir, 'mean.npy')) + std = np.load(pjoin(self.meta_dir, 'std.npy')) + + if is_test: + split_file = pjoin(self.data_root, 'test.txt') + else: + split_file = pjoin(self.data_root, 'val.txt') + + min_motion_len = 40 if self.dataset_name =='t2m' else 24 + # min_motion_len = 64 + + joints_num = self.joints_num + + data_dict = {} + id_list = [] + with cs.open(split_file, 'r') as f: + for line in f.readlines(): + id_list.append(line.strip()) + + new_name_list = [] + length_list = [] + for name in tqdm(id_list): + try: + motion = np.load(pjoin(self.motion_dir, name + '.npy')) + if (len(motion)) < min_motion_len or (len(motion) >= 200): + continue + text_data = [] + flag = False + with cs.open(pjoin(self.text_dir, name + '.txt')) as f: + for line in f.readlines(): + text_dict = {} + line_split = line.strip().split('#') + caption = line_split[0] + tokens = line_split[1].split(' ') + f_tag = float(line_split[2]) + to_tag = float(line_split[3]) + f_tag = 0.0 if np.isnan(f_tag) else f_tag + to_tag = 0.0 if np.isnan(to_tag) else to_tag + + text_dict['caption'] = caption + text_dict['tokens'] = tokens + if f_tag == 0.0 and to_tag == 0.0: + flag = True + text_data.append(text_dict) + else: + try: + n_motion = motion[int(f_tag*fps) : int(to_tag*fps)] + if (len(n_motion)) < min_motion_len or (len(n_motion) >= 200): + continue + new_name = random.choice('ABCDEFGHIJKLMNOPQRSTUVW') + '_' + name + while new_name in data_dict: + new_name = random.choice('ABCDEFGHIJKLMNOPQRSTUVW') + '_' + name + data_dict[new_name] = {'motion': n_motion, + 'length': len(n_motion), + 'text':[text_dict]} + new_name_list.append(new_name) + length_list.append(len(n_motion)) + except: + print(line_split) + print(line_split[2], line_split[3], f_tag, to_tag, name) + # break + + if flag: + data_dict[name] = {'motion': motion, + 'length': len(motion), + 'text': text_data} + new_name_list.append(name) + length_list.append(len(motion)) + except Exception as e: + # print(e) + pass + + name_list, length_list = zip(*sorted(zip(new_name_list, length_list), key=lambda x: x[1])) + self.mean = mean + self.std = std + self.length_arr = np.array(length_list) + self.data_dict = data_dict + self.name_list = name_list + self.reset_max_len(self.max_length) + + def reset_max_len(self, length): + assert length <= self.max_motion_length + self.pointer = np.searchsorted(self.length_arr, length) + print("Pointer Pointing at %d"%self.pointer) + self.max_length = length + + def inv_transform(self, data): + return data * self.std + self.mean + + def forward_transform(self, data): + return (data - self.mean) / self.std + + def __len__(self): + return len(self.data_dict) - self.pointer + + def __getitem__(self, item): + idx = self.pointer + item + name = self.name_list[idx] + data = self.data_dict[name] + # data = self.data_dict[self.name_list[idx]] + motion, m_length, text_list = data['motion'], data['length'], data['text'] + # Randomly select a caption + text_data = random.choice(text_list) + caption, tokens = text_data['caption'], text_data['tokens'] + + if len(tokens) < self.max_text_len: + # pad with "unk" + tokens = ['sos/OTHER'] + tokens + ['eos/OTHER'] + sent_len = len(tokens) + tokens = tokens + ['unk/OTHER'] * (self.max_text_len + 2 - sent_len) + else: + # crop + tokens = tokens[:self.max_text_len] + tokens = ['sos/OTHER'] + tokens + ['eos/OTHER'] + sent_len = len(tokens) + pos_one_hots = [] + word_embeddings = [] + for token in tokens: + word_emb, pos_oh = self.w_vectorizer[token] + pos_one_hots.append(pos_oh[None, :]) + word_embeddings.append(word_emb[None, :]) + pos_one_hots = np.concatenate(pos_one_hots, axis=0) + word_embeddings = np.concatenate(word_embeddings, axis=0) + + if self.unit_length < 10: + coin2 = np.random.choice(['single', 'single', 'double']) + else: + coin2 = 'single' + + if coin2 == 'double': + m_length = (m_length // self.unit_length - 1) * self.unit_length + elif coin2 == 'single': + m_length = (m_length // self.unit_length) * self.unit_length + idx = random.randint(0, len(motion) - m_length) + motion = motion[idx:idx+m_length] + + "Z Normalization" + motion = (motion - self.mean) / self.std + + if m_length < self.max_motion_length: + motion = np.concatenate([motion, + np.zeros((self.max_motion_length - m_length, motion.shape[1])) + ], axis=0) + + return word_embeddings, pos_one_hots, caption, sent_len, motion, m_length, '_'.join(tokens), name + + + + +def DATALoader(dataset_name, is_test, + batch_size, w_vectorizer, + num_workers = 8, unit_length = 4) : + + val_loader = torch.utils.data.DataLoader(Text2MotionDataset(dataset_name, is_test, w_vectorizer, unit_length=unit_length), + batch_size, + shuffle = True, + num_workers=num_workers, + collate_fn=collate_fn, + drop_last = True) + return val_loader + + +def cycle(iterable): + while True: + for x in iterable: + yield x diff --git a/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_train.py b/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_train.py new file mode 100644 index 0000000000000000000000000000000000000000..0b0223effb01c1cf57fa6b2b6fb8d9d01b83f84a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/dataset_TM_train.py @@ -0,0 +1,161 @@ +import torch +from torch.utils import data +import numpy as np +from os.path import join as pjoin +import random +import codecs as cs +from tqdm import tqdm +import utils.paramUtil as paramUtil +from torch.utils.data._utils.collate import default_collate + + +def collate_fn(batch): + batch.sort(key=lambda x: x[3], reverse=True) + return default_collate(batch) + + +'''For use of training text-2-motion generative model''' +class Text2MotionDataset(data.Dataset): + def __init__(self, dataset_name, feat_bias = 5, unit_length = 4, codebook_size = 1024, tokenizer_name=None): + + self.max_length = 64 + self.pointer = 0 + self.dataset_name = dataset_name + + self.unit_length = unit_length + # self.mot_start_idx = codebook_size + self.mot_end_idx = codebook_size + self.mot_pad_idx = codebook_size + 1 + if dataset_name == 't2m': + self.data_root = './dataset/HumanML3D' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 22 + radius = 4 + fps = 20 + self.max_motion_length = 26 if unit_length == 8 else 51 + dim_pose = 263 + kinematic_chain = paramUtil.t2m_kinematic_chain + elif dataset_name == 'kit': + self.data_root = './dataset/KIT-ML' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 21 + radius = 240 * 8 + fps = 12.5 + dim_pose = 251 + self.max_motion_length = 26 if unit_length == 8 else 51 + kinematic_chain = paramUtil.kit_kinematic_chain + + split_file = pjoin(self.data_root, 'train.txt') + + + id_list = [] + with cs.open(split_file, 'r') as f: + for line in f.readlines(): + id_list.append(line.strip()) + + new_name_list = [] + data_dict = {} + for name in tqdm(id_list): + try: + m_token_list = np.load(pjoin(self.data_root, tokenizer_name, '%s.npy'%name)) + + # Read text + with cs.open(pjoin(self.text_dir, name + '.txt')) as f: + text_data = [] + flag = False + lines = f.readlines() + + for line in lines: + try: + text_dict = {} + line_split = line.strip().split('#') + caption = line_split[0] + t_tokens = line_split[1].split(' ') + f_tag = float(line_split[2]) + to_tag = float(line_split[3]) + f_tag = 0.0 if np.isnan(f_tag) else f_tag + to_tag = 0.0 if np.isnan(to_tag) else to_tag + + text_dict['caption'] = caption + text_dict['tokens'] = t_tokens + if f_tag == 0.0 and to_tag == 0.0: + flag = True + text_data.append(text_dict) + else: + m_token_list_new = [tokens[int(f_tag*fps/unit_length) : int(to_tag*fps/unit_length)] for tokens in m_token_list if int(f_tag*fps/unit_length) < int(to_tag*fps/unit_length)] + + if len(m_token_list_new) == 0: + continue + new_name = '%s_%f_%f'%(name, f_tag, to_tag) + + data_dict[new_name] = {'m_token_list': m_token_list_new, + 'text':[text_dict]} + new_name_list.append(new_name) + except: + pass + + if flag: + data_dict[name] = {'m_token_list': m_token_list, + 'text':text_data} + new_name_list.append(name) + except: + pass + self.data_dict = data_dict + self.name_list = new_name_list + + def __len__(self): + return len(self.data_dict) + + def __getitem__(self, item): + data = self.data_dict[self.name_list[item]] + m_token_list, text_list = data['m_token_list'], data['text'] + m_tokens = random.choice(m_token_list) + + text_data = random.choice(text_list) + caption= text_data['caption'] + + + coin = np.random.choice([False, False, True]) + # print(len(m_tokens)) + if coin: + # drop one token at the head or tail + coin2 = np.random.choice([True, False]) + if coin2: + m_tokens = m_tokens[:-1] + else: + m_tokens = m_tokens[1:] + m_tokens_len = m_tokens.shape[0] + + if m_tokens_len+1 < self.max_motion_length: + m_tokens = np.concatenate([m_tokens, np.ones((1), dtype=int) * self.mot_end_idx, np.ones((self.max_motion_length-1-m_tokens_len), dtype=int) * self.mot_pad_idx], axis=0) + else: + m_tokens = np.concatenate([m_tokens, np.ones((1), dtype=int) * self.mot_end_idx], axis=0) + + return caption, m_tokens.reshape(-1), m_tokens_len + + + + +def DATALoader(dataset_name, + batch_size, codebook_size, tokenizer_name, unit_length=4, + num_workers = 8) : + + train_loader = torch.utils.data.DataLoader(Text2MotionDataset(dataset_name, codebook_size = codebook_size, tokenizer_name = tokenizer_name, unit_length=unit_length), + batch_size, + shuffle=True, + num_workers=num_workers, + #collate_fn=collate_fn, + drop_last = True) + + + return train_loader + + +def cycle(iterable): + while True: + for x in iterable: + yield x + + diff --git a/MuseV/MMCM/mmcm/t2p/dataset/dataset_VQ.py b/MuseV/MMCM/mmcm/t2p/dataset/dataset_VQ.py new file mode 100644 index 0000000000000000000000000000000000000000..2342de946f2cbdf64729a5145168df1bdda54fa0 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/dataset_VQ.py @@ -0,0 +1,109 @@ +import torch +from torch.utils import data +import numpy as np +from os.path import join as pjoin +import random +import codecs as cs +from tqdm import tqdm + + + +class VQMotionDataset(data.Dataset): + def __init__(self, dataset_name, window_size = 64, unit_length = 4): + self.window_size = window_size + self.unit_length = unit_length + self.dataset_name = dataset_name + + if dataset_name == 't2m': + self.data_root = './dataset/HumanML3D' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 22 + self.max_motion_length = 196 + self.meta_dir = 'checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + + elif dataset_name == 'kit': + self.data_root = './dataset/KIT-ML' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 21 + + self.max_motion_length = 196 + self.meta_dir = 'checkpoints/kit/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + + joints_num = self.joints_num + + mean = np.load(pjoin(self.meta_dir, 'mean.npy')) + std = np.load(pjoin(self.meta_dir, 'std.npy')) + + split_file = pjoin(self.data_root, 'train.txt') + + self.data = [] + self.lengths = [] + id_list = [] + with cs.open(split_file, 'r') as f: + for line in f.readlines(): + id_list.append(line.strip()) + + for name in tqdm(id_list): + try: + motion = np.load(pjoin(self.motion_dir, name + '.npy')) + if motion.shape[0] < self.window_size: + continue + self.lengths.append(motion.shape[0] - self.window_size) + self.data.append(motion) + except: + # Some motion may not exist in KIT dataset + pass + + + self.mean = mean + self.std = std + print("Total number of motions {}".format(len(self.data))) + + def inv_transform(self, data): + return data * self.std + self.mean + + def compute_sampling_prob(self) : + + prob = np.array(self.lengths, dtype=np.float32) + prob /= np.sum(prob) + return prob + + def __len__(self): + return len(self.data) + + def __getitem__(self, item): + motion = self.data[item] + + idx = random.randint(0, len(motion) - self.window_size) + + motion = motion[idx:idx+self.window_size] + "Z Normalization" + motion = (motion - self.mean) / self.std + + return motion + +def DATALoader(dataset_name, + batch_size, + num_workers = 8, + window_size = 64, + unit_length = 4): + + trainSet = VQMotionDataset(dataset_name, window_size=window_size, unit_length=unit_length) + prob = trainSet.compute_sampling_prob() + sampler = torch.utils.data.WeightedRandomSampler(prob, num_samples = len(trainSet) * 1000, replacement=True) + train_loader = torch.utils.data.DataLoader(trainSet, + batch_size, + shuffle=True, + #sampler=sampler, + num_workers=num_workers, + #collate_fn=collate_fn, + drop_last = True) + + return train_loader + +def cycle(iterable): + while True: + for x in iterable: + yield x diff --git a/MuseV/MMCM/mmcm/t2p/dataset/dataset_tokenize.py b/MuseV/MMCM/mmcm/t2p/dataset/dataset_tokenize.py new file mode 100644 index 0000000000000000000000000000000000000000..641a02a75f2cfaadea45851cad2a95b39bfa1eae --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/dataset_tokenize.py @@ -0,0 +1,117 @@ +import torch +from torch.utils import data +import numpy as np +from os.path import join as pjoin +import random +import codecs as cs +from tqdm import tqdm + + + +class VQMotionDataset(data.Dataset): + def __init__(self, dataset_name, feat_bias = 5, window_size = 64, unit_length = 8): + self.window_size = window_size + self.unit_length = unit_length + self.feat_bias = feat_bias + + self.dataset_name = dataset_name + min_motion_len = 40 if dataset_name =='t2m' else 24 + + if dataset_name == 't2m': + self.data_root = './dataset/HumanML3D' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 22 + radius = 4 + fps = 20 + self.max_motion_length = 196 + dim_pose = 263 + self.meta_dir = 'checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + #kinematic_chain = paramUtil.t2m_kinematic_chain + elif dataset_name == 'kit': + self.data_root = './dataset/KIT-ML' + self.motion_dir = pjoin(self.data_root, 'new_joint_vecs') + self.text_dir = pjoin(self.data_root, 'texts') + self.joints_num = 21 + radius = 240 * 8 + fps = 12.5 + dim_pose = 251 + self.max_motion_length = 196 + self.meta_dir = 'checkpoints/kit/VQVAEV3_CB1024_CMT_H1024_NRES3/meta' + #kinematic_chain = paramUtil.kit_kinematic_chain + + joints_num = self.joints_num + + mean = np.load(pjoin(self.meta_dir, 'mean.npy')) + std = np.load(pjoin(self.meta_dir, 'std.npy')) + + split_file = pjoin(self.data_root, 'train.txt') + + data_dict = {} + id_list = [] + with cs.open(split_file, 'r') as f: + for line in f.readlines(): + id_list.append(line.strip()) + + new_name_list = [] + length_list = [] + for name in tqdm(id_list): + try: + motion = np.load(pjoin(self.motion_dir, name + '.npy')) + if (len(motion)) < min_motion_len or (len(motion) >= 200): + continue + + data_dict[name] = {'motion': motion, + 'length': len(motion), + 'name': name} + new_name_list.append(name) + length_list.append(len(motion)) + except: + # Some motion may not exist in KIT dataset + pass + + + self.mean = mean + self.std = std + self.length_arr = np.array(length_list) + self.data_dict = data_dict + self.name_list = new_name_list + + def inv_transform(self, data): + return data * self.std + self.mean + + def __len__(self): + return len(self.data_dict) + + def __getitem__(self, item): + name = self.name_list[item] + data = self.data_dict[name] + motion, m_length = data['motion'], data['length'] + + m_length = (m_length // self.unit_length) * self.unit_length + + idx = random.randint(0, len(motion) - m_length) + motion = motion[idx:idx+m_length] + + "Z Normalization" + motion = (motion - self.mean) / self.std + + return motion, name + +def DATALoader(dataset_name, + batch_size = 1, + num_workers = 8, unit_length = 4) : + + train_loader = torch.utils.data.DataLoader(VQMotionDataset(dataset_name, unit_length=unit_length), + batch_size, + shuffle=True, + num_workers=num_workers, + #collate_fn=collate_fn, + drop_last = True) + + return train_loader + +def cycle(iterable): + while True: + for x in iterable: + yield x diff --git a/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_extractor.sh b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_extractor.sh new file mode 100644 index 0000000000000000000000000000000000000000..d6f8a14a437687f6f10bb7bc08cd073a0884ca16 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_extractor.sh @@ -0,0 +1,15 @@ +rm -rf checkpoints +mkdir checkpoints +cd checkpoints +echo -e "Downloading extractors" +gdown --fuzzy https://drive.google.com/file/d/1o7RTDQcToJjTm9_mNWTyzvZvjTWpZfug/view +gdown --fuzzy https://drive.google.com/file/d/1KNU8CsMAnxFrwopKBBkC8jEULGLPBHQp/view + + +unzip t2m.zip +unzip kit.zip + +echo -e "Cleaning\n" +rm t2m.zip +rm kit.zip +echo -e "Downloading done!" \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_glove.sh b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_glove.sh new file mode 100644 index 0000000000000000000000000000000000000000..058599aa32c9c97e0e3fc0a9658822e9c904955a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_glove.sh @@ -0,0 +1,9 @@ +echo -e "Downloading glove (in use by the evaluators)" +gdown --fuzzy https://drive.google.com/file/d/1bCeS6Sh_mLVTebxIgiUHgdPrroW06mb6/view?usp=sharing +rm -rf glove + +unzip glove.zip +echo -e "Cleaning\n" +rm glove.zip + +echo -e "Downloading done!" \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_model.sh b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_model.sh new file mode 100644 index 0000000000000000000000000000000000000000..da32436f6efa93e0c14e1dd52f97068bd75956ab --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_model.sh @@ -0,0 +1,12 @@ + +mkdir -p pretrained +cd pretrained/ + +echo -e "The pretrained model files will be stored in the 'pretrained' folder\n" +gdown 1LaOvwypF-jM2Axnq5dc-Iuvv3w_G-WDE + +unzip VQTrans_pretrained.zip +echo -e "Cleaning\n" +rm VQTrans_pretrained.zip + +echo -e "Downloading done!" \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_smpl.sh b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_smpl.sh new file mode 100644 index 0000000000000000000000000000000000000000..411325b509e891d96b859bf28f7b983005ca360a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/dataset/prepare/download_smpl.sh @@ -0,0 +1,13 @@ + +mkdir -p body_models +cd body_models/ + +echo -e "The smpl files will be stored in the 'body_models/smpl/' folder\n" +gdown 1INYlGA76ak_cKGzvpOV2Pe6RkYTlXTW2 +rm -rf smpl + +unzip smpl.zip +echo -e "Cleaning\n" +rm smpl.zip + +echo -e "Downloading done!" \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/environment.yml b/MuseV/MMCM/mmcm/t2p/environment.yml new file mode 100755 index 0000000000000000000000000000000000000000..3acca42a39129dc722810eaa0f35a8c79952896f --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/environment.yml @@ -0,0 +1,121 @@ +name: T2M-GPT +channels: + - pytorch + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=4.5=1_gnu + - blas=1.0=mkl + - bzip2=1.0.8=h7b6447c_0 + - ca-certificates=2021.7.5=h06a4308_1 + - certifi=2021.5.30=py38h06a4308_0 + - cudatoolkit=10.1.243=h6bb024c_0 + - ffmpeg=4.3=hf484d3e_0 + - freetype=2.10.4=h5ab3b9f_0 + - gmp=6.2.1=h2531618_2 + - gnutls=3.6.15=he1e5248_0 + - intel-openmp=2021.3.0=h06a4308_3350 + - jpeg=9b=h024ee3a_2 + - lame=3.100=h7b6447c_0 + - lcms2=2.12=h3be6417_0 + - ld_impl_linux-64=2.35.1=h7274673_9 + - libffi=3.3=he6710b0_2 + - libgcc-ng=9.3.0=h5101ec6_17 + - libgomp=9.3.0=h5101ec6_17 + - libiconv=1.15=h63c8f33_5 + - libidn2=2.3.2=h7f8727e_0 + - libpng=1.6.37=hbc83047_0 + - libstdcxx-ng=9.3.0=hd4cf53a_17 + - libtasn1=4.16.0=h27cfd23_0 + - libtiff=4.2.0=h85742a9_0 + - libunistring=0.9.10=h27cfd23_0 + - libuv=1.40.0=h7b6447c_fxfi0 + - libwebp-base=1.2.0=h27cfd23_0 + - lz4-c=1.9.3=h295c915_1 + - mkl=2021.3.0=h06a4308_520 + - mkl-service=2.4.0=py38h7f8727e_0 + - mkl_fft=1.3.0=py38h42c9631_2 + - mkl_random=1.2.2=py38h51133e4_0 + - ncurses=6.2=he6710b0_1 + - nettle=3.7.3=hbbd107a_1 + - ninja=1.10.2=hff7bd54_1 + - numpy=1.20.3=py38hf144106_0 + - numpy-base=1.20.3=py38h74d4b33_0 + - olefile=0.46=py_0 + - openh264=2.1.0=hd408876_0 + - openjpeg=2.3.0=h05c96fa_1 + - openssl=1.1.1k=h27cfd23_0 + - pillow=8.3.1=py38h2c7a002_0 + - pip=21.0.1=py38h06a4308_0 + - python=3.8.11=h12debd9_0_cpython + - pytorch=1.8.1=py3.8_cuda10.1_cudnn7.6.3_0 + - readline=8.1=h27cfd23_0 + - setuptools=52.0.0=py38h06a4308_0 + - six=1.16.0=pyhd3eb1b0_0 + - sqlite=3.36.0=hc218d9a_0 + - tk=8.6.10=hbc83047_0 + - torchaudio=0.8.1=py38 + - torchvision=0.9.1=py38_cu101 + - typing_extensions=3.10.0.0=pyh06a4308_0 + - wheel=0.37.0=pyhd3eb1b0_0 + - xz=5.2.5=h7b6447c_0 + - zlib=1.2.11=h7b6447c_3 + - zstd=1.4.9=haebb681_0 + - pip: + - absl-py==0.13.0 + - backcall==0.2.0 + - cachetools==4.2.2 + - charset-normalizer==2.0.4 + - chumpy==0.70 + - cycler==0.10.0 + - decorator==5.0.9 + - google-auth==1.35.0 + - google-auth-oauthlib==0.4.5 + - grpcio==1.39.0 + - idna==3.2 + - imageio==2.9.0 + - ipdb==0.13.9 + - ipython==7.26.0 + - ipython-genutils==0.2.0 + - jedi==0.18.0 + - joblib==1.0.1 + - kiwisolver==1.3.1 + - markdown==3.3.4 + - matplotlib==3.4.3 + - matplotlib-inline==0.1.2 + - oauthlib==3.1.1 + - pandas==1.3.2 + - parso==0.8.2 + - pexpect==4.8.0 + - pickleshare==0.7.5 + - prompt-toolkit==3.0.20 + - protobuf==3.17.3 + - ptyprocess==0.7.0 + - pyasn1==0.4.8 + - pyasn1-modules==0.2.8 + - pygments==2.10.0 + - pyparsing==2.4.7 + - python-dateutil==2.8.2 + - pytz==2021.1 + - pyyaml==5.4.1 + - requests==2.26.0 + - requests-oauthlib==1.3.0 + - rsa==4.7.2 + - scikit-learn==0.24.2 + - scipy==1.7.1 + - sklearn==0.0 + - smplx==0.1.28 + - tensorboard==2.6.0 + - tensorboard-data-server==0.6.1 + - tensorboard-plugin-wit==1.8.0 + - threadpoolctl==2.2.0 + - toml==0.10.2 + - tqdm==4.62.2 + - traitlets==5.0.5 + - urllib3==1.26.6 + - wcwidth==0.2.5 + - werkzeug==2.0.1 + - git+https://mirrors.tencent.com/github.com/openai/CLIP.git + - git+https://mirrors.tencent.com/github.com/nghorbani/human_body_prior + - gdown + - moviepy diff --git a/MuseV/MMCM/mmcm/t2p/example.gif b/MuseV/MMCM/mmcm/t2p/example.gif new file mode 100755 index 0000000000000000000000000000000000000000..497963d34f4b0c06ae0a669d68a2a085107de1a7 Binary files /dev/null and b/MuseV/MMCM/mmcm/t2p/example.gif differ diff --git a/MuseV/MMCM/mmcm/t2p/models/encdec.py b/MuseV/MMCM/mmcm/t2p/models/encdec.py new file mode 100755 index 0000000000000000000000000000000000000000..7a42c66a56d295497617eb6dd3ff1b71ebb3c490 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/encdec.py @@ -0,0 +1,67 @@ +import torch.nn as nn +from .resnet import Resnet1D + +class Encoder(nn.Module): + def __init__(self, + input_emb_width = 3, + output_emb_width = 512, + down_t = 3, + stride_t = 2, + width = 512, + depth = 3, + dilation_growth_rate = 3, + activation='relu', + norm=None): + super().__init__() + + blocks = [] + filter_t, pad_t = stride_t * 2, stride_t // 2 + blocks.append(nn.Conv1d(input_emb_width, width, 3, 1, 1)) + blocks.append(nn.ReLU()) + + for i in range(down_t): + input_dim = width + block = nn.Sequential( + nn.Conv1d(input_dim, width, filter_t, stride_t, pad_t), + Resnet1D(width, depth, dilation_growth_rate, activation=activation, norm=norm), + ) + blocks.append(block) + blocks.append(nn.Conv1d(width, output_emb_width, 3, 1, 1)) + self.model = nn.Sequential(*blocks) + + def forward(self, x): + return self.model(x) + +class Decoder(nn.Module): + def __init__(self, + input_emb_width = 3, + output_emb_width = 512, + down_t = 3, + stride_t = 2, + width = 512, + depth = 3, + dilation_growth_rate = 3, + activation='relu', + norm=None): + super().__init__() + blocks = [] + + filter_t, pad_t = stride_t * 2, stride_t // 2 + blocks.append(nn.Conv1d(output_emb_width, width, 3, 1, 1)) + blocks.append(nn.ReLU()) + for i in range(down_t): + out_dim = width + block = nn.Sequential( + Resnet1D(width, depth, dilation_growth_rate, reverse_dilation=True, activation=activation, norm=norm), + nn.Upsample(scale_factor=2, mode='nearest'), + nn.Conv1d(width, out_dim, 3, 1, 1) + ) + blocks.append(block) + blocks.append(nn.Conv1d(width, width, 3, 1, 1)) + blocks.append(nn.ReLU()) + blocks.append(nn.Conv1d(width, input_emb_width, 3, 1, 1)) + self.model = nn.Sequential(*blocks) + + def forward(self, x): + return self.model(x) + diff --git a/MuseV/MMCM/mmcm/t2p/models/evaluator_wrapper.py b/MuseV/MMCM/mmcm/t2p/models/evaluator_wrapper.py new file mode 100755 index 0000000000000000000000000000000000000000..5ce1ea59963b140362fed59be9050a4c515b45ef --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/evaluator_wrapper.py @@ -0,0 +1,92 @@ + +import torch +from os.path import join as pjoin +import numpy as np +from .modules import MovementConvEncoder, TextEncoderBiGRUCo, MotionEncoderBiGRUCo +from ..utils.word_vectorizer import POS_enumerator + +def build_models(opt): + movement_enc = MovementConvEncoder(opt.dim_pose-4, opt.dim_movement_enc_hidden, opt.dim_movement_latent) + text_enc = TextEncoderBiGRUCo(word_size=opt.dim_word, + pos_size=opt.dim_pos_ohot, + hidden_size=opt.dim_text_hidden, + output_size=opt.dim_coemb_hidden, + device=opt.device) + + motion_enc = MotionEncoderBiGRUCo(input_size=opt.dim_movement_latent, + hidden_size=opt.dim_motion_hidden, + output_size=opt.dim_coemb_hidden, + device=opt.device) + + checkpoint = torch.load(pjoin(opt.checkpoints_dir, opt.dataset_name, 'text_mot_match', 'model', 'finest.tar'), + map_location=opt.device) + movement_enc.load_state_dict(checkpoint['movement_encoder']) + text_enc.load_state_dict(checkpoint['text_encoder']) + motion_enc.load_state_dict(checkpoint['motion_encoder']) + print('Loading Evaluation Model Wrapper (Epoch %d) Completed!!' % (checkpoint['epoch'])) + return text_enc, motion_enc, movement_enc + + +class EvaluatorModelWrapper(object): + + def __init__(self, opt): + + if opt.dataset_name == 't2m': + opt.dim_pose = 263 + elif opt.dataset_name == 'kit': + opt.dim_pose = 251 + else: + raise KeyError('Dataset not Recognized!!!') + + opt.dim_word = 300 + opt.max_motion_length = 196 + opt.dim_pos_ohot = len(POS_enumerator) + opt.dim_motion_hidden = 1024 + opt.max_text_len = 20 + opt.dim_text_hidden = 512 + opt.dim_coemb_hidden = 512 + + # print(opt) + + self.text_encoder, self.motion_encoder, self.movement_encoder = build_models(opt) + self.opt = opt + self.device = opt.device + + self.text_encoder.to(opt.device) + self.motion_encoder.to(opt.device) + self.movement_encoder.to(opt.device) + + self.text_encoder.eval() + self.motion_encoder.eval() + self.movement_encoder.eval() + + # Please note that the results does not following the order of inputs + def get_co_embeddings(self, word_embs, pos_ohot, cap_lens, motions, m_lens): + with torch.no_grad(): + word_embs = word_embs.detach().to(self.device).float() + pos_ohot = pos_ohot.detach().to(self.device).float() + motions = motions.detach().to(self.device).float() + + '''Movement Encoding''' + movements = self.movement_encoder(motions[..., :-4]).detach() + m_lens = m_lens // self.opt.unit_length + motion_embedding = self.motion_encoder(movements, m_lens) + + '''Text Encoding''' + text_embedding = self.text_encoder(word_embs, pos_ohot, cap_lens) + return text_embedding, motion_embedding + + # Please note that the results does not following the order of inputs + def get_motion_embeddings(self, motions, m_lens): + with torch.no_grad(): + motions = motions.detach().to(self.device).float() + + align_idx = np.argsort(m_lens.data.tolist())[::-1].copy() + motions = motions[align_idx] + m_lens = m_lens[align_idx] + + '''Movement Encoding''' + movements = self.movement_encoder(motions[..., :-4]).detach() + m_lens = m_lens // self.opt.unit_length + motion_embedding = self.motion_encoder(movements, m_lens) + return motion_embedding diff --git a/MuseV/MMCM/mmcm/t2p/models/modules.py b/MuseV/MMCM/mmcm/t2p/models/modules.py new file mode 100755 index 0000000000000000000000000000000000000000..4f06cd98d4f6029bd3df073095cf50498483d54a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/modules.py @@ -0,0 +1,109 @@ +import torch +import torch.nn as nn +from torch.nn.utils.rnn import pack_padded_sequence + +def init_weight(m): + if isinstance(m, nn.Conv1d) or isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose1d): + nn.init.xavier_normal_(m.weight) + # m.bias.data.fill_(0.01) + if m.bias is not None: + nn.init.constant_(m.bias, 0) + + +class MovementConvEncoder(nn.Module): + def __init__(self, input_size, hidden_size, output_size): + super(MovementConvEncoder, self).__init__() + self.main = nn.Sequential( + nn.Conv1d(input_size, hidden_size, 4, 2, 1), + nn.Dropout(0.2, inplace=True), + nn.LeakyReLU(0.2, inplace=True), + nn.Conv1d(hidden_size, output_size, 4, 2, 1), + nn.Dropout(0.2, inplace=True), + nn.LeakyReLU(0.2, inplace=True), + ) + self.out_net = nn.Linear(output_size, output_size) + self.main.apply(init_weight) + self.out_net.apply(init_weight) + + def forward(self, inputs): + inputs = inputs.permute(0, 2, 1) + outputs = self.main(inputs).permute(0, 2, 1) + # print(outputs.shape) + return self.out_net(outputs) + + + +class TextEncoderBiGRUCo(nn.Module): + def __init__(self, word_size, pos_size, hidden_size, output_size, device): + super(TextEncoderBiGRUCo, self).__init__() + self.device = device + + self.pos_emb = nn.Linear(pos_size, word_size) + self.input_emb = nn.Linear(word_size, hidden_size) + self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True) + self.output_net = nn.Sequential( + nn.Linear(hidden_size * 2, hidden_size), + nn.LayerNorm(hidden_size), + nn.LeakyReLU(0.2, inplace=True), + nn.Linear(hidden_size, output_size) + ) + + self.input_emb.apply(init_weight) + self.pos_emb.apply(init_weight) + self.output_net.apply(init_weight) + self.hidden_size = hidden_size + self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True)) + + # input(batch_size, seq_len, dim) + def forward(self, word_embs, pos_onehot, cap_lens): + num_samples = word_embs.shape[0] + + pos_embs = self.pos_emb(pos_onehot) + inputs = word_embs + pos_embs + input_embs = self.input_emb(inputs) + hidden = self.hidden.repeat(1, num_samples, 1) + + cap_lens = cap_lens.data.tolist() + emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True) + + gru_seq, gru_last = self.gru(emb, hidden) + + gru_last = torch.cat([gru_last[0], gru_last[1]], dim=-1) + + return self.output_net(gru_last) + + +class MotionEncoderBiGRUCo(nn.Module): + def __init__(self, input_size, hidden_size, output_size, device): + super(MotionEncoderBiGRUCo, self).__init__() + self.device = device + + self.input_emb = nn.Linear(input_size, hidden_size) + self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True) + self.output_net = nn.Sequential( + nn.Linear(hidden_size*2, hidden_size), + nn.LayerNorm(hidden_size), + nn.LeakyReLU(0.2, inplace=True), + nn.Linear(hidden_size, output_size) + ) + + self.input_emb.apply(init_weight) + self.output_net.apply(init_weight) + self.hidden_size = hidden_size + self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True)) + + # input(batch_size, seq_len, dim) + def forward(self, inputs, m_lens): + num_samples = inputs.shape[0] + + input_embs = self.input_emb(inputs) + hidden = self.hidden.repeat(1, num_samples, 1) + + cap_lens = m_lens.data.tolist() + emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True, enforce_sorted=False) + + gru_seq, gru_last = self.gru(emb, hidden) + + gru_last = torch.cat([gru_last[0], gru_last[1]], dim=-1) + + return self.output_net(gru_last) diff --git a/MuseV/MMCM/mmcm/t2p/models/pos_encoding.py b/MuseV/MMCM/mmcm/t2p/models/pos_encoding.py new file mode 100755 index 0000000000000000000000000000000000000000..066be3e1f8a1636f7eaabd1c534b9c618ee3e9f8 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/pos_encoding.py @@ -0,0 +1,43 @@ +""" +Various positional encodings for the transformer. +""" +import math +import torch +from torch import nn + +def PE1d_sincos(seq_length, dim): + """ + :param d_model: dimension of the model + :param length: length of positions + :return: length*d_model position matrix + """ + if dim % 2 != 0: + raise ValueError("Cannot use sin/cos positional encoding with " + "odd dim (got dim={:d})".format(dim)) + pe = torch.zeros(seq_length, dim) + position = torch.arange(0, seq_length).unsqueeze(1) + div_term = torch.exp((torch.arange(0, dim, 2, dtype=torch.float) * + -(math.log(10000.0) / dim))) + pe[:, 0::2] = torch.sin(position.float() * div_term) + pe[:, 1::2] = torch.cos(position.float() * div_term) + + return pe.unsqueeze(1) + + +class PositionEmbedding(nn.Module): + """ + Absolute pos embedding (standard), learned. + """ + def __init__(self, seq_length, dim, dropout, grad=False): + super().__init__() + self.embed = nn.Parameter(data=PE1d_sincos(seq_length, dim), requires_grad=grad) + self.dropout = nn.Dropout(p=dropout) + + def forward(self, x): + # x.shape: bs, seq_len, feat_dim + l = x.shape[1] + x = x.permute(1, 0, 2) + self.embed[:l].expand(x.permute(1, 0, 2).shape) + x = self.dropout(x.permute(1, 0, 2)) + return x + + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/models/quantize_cnn.py b/MuseV/MMCM/mmcm/t2p/models/quantize_cnn.py new file mode 100755 index 0000000000000000000000000000000000000000..8cd3ecddb8f8f07bdb4ae6f963c3a401c6bb1ef3 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/quantize_cnn.py @@ -0,0 +1,413 @@ +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +class QuantizeEMAReset(nn.Module): + def __init__(self, nb_code, code_dim, args): + super().__init__() + self.nb_code = nb_code + self.code_dim = code_dim + self.mu = args.mu + self.reset_codebook() + + def reset_codebook(self): + self.init = False + self.code_sum = None + self.code_count = None + self.register_buffer('codebook', torch.zeros(self.nb_code, self.code_dim).cuda()) + + def _tile(self, x): + nb_code_x, code_dim = x.shape + if nb_code_x < self.nb_code: + n_repeats = (self.nb_code + nb_code_x - 1) // nb_code_x + std = 0.01 / np.sqrt(code_dim) + out = x.repeat(n_repeats, 1) + out = out + torch.randn_like(out) * std + else : + out = x + return out + + def init_codebook(self, x): + out = self._tile(x) + self.codebook = out[:self.nb_code] + self.code_sum = self.codebook.clone() + self.code_count = torch.ones(self.nb_code, device=self.codebook.device) + self.init = True + + @torch.no_grad() + def compute_perplexity(self, code_idx) : + # Calculate new centres + code_onehot = torch.zeros(self.nb_code, code_idx.shape[0], device=code_idx.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, code_idx.shape[0]), 1) + + code_count = code_onehot.sum(dim=-1) # nb_code + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + return perplexity + + @torch.no_grad() + def update_codebook(self, x, code_idx): + + code_onehot = torch.zeros(self.nb_code, x.shape[0], device=x.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, x.shape[0]), 1) + + code_sum = torch.matmul(code_onehot, x) # nb_code, w + code_count = code_onehot.sum(dim=-1) # nb_code + + out = self._tile(x) + code_rand = out[:self.nb_code] + + # Update centres + self.code_sum = self.mu * self.code_sum + (1. - self.mu) * code_sum # w, nb_code + self.code_count = self.mu * self.code_count + (1. - self.mu) * code_count # nb_code + + usage = (self.code_count.view(self.nb_code, 1) >= 1.0).float() + code_update = self.code_sum.view(self.nb_code, self.code_dim) / self.code_count.view(self.nb_code, 1) + + self.codebook = usage * code_update + (1 - usage) * code_rand + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + + + return perplexity + + def preprocess(self, x): + # NCT -> NTC -> [NT, C] + x = x.permute(0, 2, 1).contiguous() + x = x.view(-1, x.shape[-1]) + return x + + def quantize(self, x): + # Calculate latent code x_l + k_w = self.codebook.t() + distance = torch.sum(x ** 2, dim=-1, keepdim=True) - 2 * torch.matmul(x, k_w) + torch.sum(k_w ** 2, dim=0, + keepdim=True) # (N * L, b) + _, code_idx = torch.min(distance, dim=-1) + return code_idx + + def dequantize(self, code_idx): + x = F.embedding(code_idx, self.codebook) + return x + + + def forward(self, x): + N, width, T = x.shape + + # Preprocess + x = self.preprocess(x) + + # Init codebook if not inited + if self.training and not self.init: + self.init_codebook(x) + + # quantize and dequantize through bottleneck + code_idx = self.quantize(x) + x_d = self.dequantize(code_idx) + + # Update embeddings + if self.training: + perplexity = self.update_codebook(x, code_idx) + else : + perplexity = self.compute_perplexity(code_idx) + + # Loss + commit_loss = F.mse_loss(x, x_d.detach()) + + # Passthrough + x_d = x + (x_d - x).detach() + + # Postprocess + x_d = x_d.view(N, T, -1).permute(0, 2, 1).contiguous() #(N, DIM, T) + + return x_d, commit_loss, perplexity + + + +class Quantizer(nn.Module): + def __init__(self, n_e, e_dim, beta): + super(Quantizer, self).__init__() + + self.e_dim = e_dim + self.n_e = n_e + self.beta = beta + + self.embedding = nn.Embedding(self.n_e, self.e_dim) + self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e) + + def forward(self, z): + + N, width, T = z.shape + z = self.preprocess(z) + assert z.shape[-1] == self.e_dim + z_flattened = z.contiguous().view(-1, self.e_dim) + + # B x V + d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight**2, dim=1) - 2 * \ + torch.matmul(z_flattened, self.embedding.weight.t()) + # B x 1 + min_encoding_indices = torch.argmin(d, dim=1) + z_q = self.embedding(min_encoding_indices).view(z.shape) + + # compute loss for embedding + loss = torch.mean((z_q - z.detach())**2) + self.beta * \ + torch.mean((z_q.detach() - z)**2) + + # preserve gradients + z_q = z + (z_q - z).detach() + z_q = z_q.view(N, T, -1).permute(0, 2, 1).contiguous() #(N, DIM, T) + + min_encodings = F.one_hot(min_encoding_indices, self.n_e).type(z.dtype) + e_mean = torch.mean(min_encodings, dim=0) + perplexity = torch.exp(-torch.sum(e_mean*torch.log(e_mean + 1e-10))) + return z_q, loss, perplexity + + def quantize(self, z): + + assert z.shape[-1] == self.e_dim + + # B x V + d = torch.sum(z ** 2, dim=1, keepdim=True) + \ + torch.sum(self.embedding.weight ** 2, dim=1) - 2 * \ + torch.matmul(z, self.embedding.weight.t()) + # B x 1 + min_encoding_indices = torch.argmin(d, dim=1) + return min_encoding_indices + + def dequantize(self, indices): + + index_flattened = indices.view(-1) + z_q = self.embedding(index_flattened) + z_q = z_q.view(indices.shape + (self.e_dim, )).contiguous() + return z_q + + def preprocess(self, x): + # NCT -> NTC -> [NT, C] + x = x.permute(0, 2, 1).contiguous() + x = x.view(-1, x.shape[-1]) + return x + + + +class QuantizeReset(nn.Module): + def __init__(self, nb_code, code_dim, args): + super().__init__() + self.nb_code = nb_code + self.code_dim = code_dim + self.reset_codebook() + self.codebook = nn.Parameter(torch.randn(nb_code, code_dim)) + + def reset_codebook(self): + self.init = False + self.code_count = None + + def _tile(self, x): + nb_code_x, code_dim = x.shape + if nb_code_x < self.nb_code: + n_repeats = (self.nb_code + nb_code_x - 1) // nb_code_x + std = 0.01 / np.sqrt(code_dim) + out = x.repeat(n_repeats, 1) + out = out + torch.randn_like(out) * std + else : + out = x + return out + + def init_codebook(self, x): + out = self._tile(x) + self.codebook = nn.Parameter(out[:self.nb_code]) + self.code_count = torch.ones(self.nb_code, device=self.codebook.device) + self.init = True + + @torch.no_grad() + def compute_perplexity(self, code_idx) : + # Calculate new centres + code_onehot = torch.zeros(self.nb_code, code_idx.shape[0], device=code_idx.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, code_idx.shape[0]), 1) + + code_count = code_onehot.sum(dim=-1) # nb_code + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + return perplexity + + def update_codebook(self, x, code_idx): + + code_onehot = torch.zeros(self.nb_code, x.shape[0], device=x.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, x.shape[0]), 1) + + code_count = code_onehot.sum(dim=-1) # nb_code + + out = self._tile(x) + code_rand = out[:self.nb_code] + + # Update centres + self.code_count = code_count # nb_code + usage = (self.code_count.view(self.nb_code, 1) >= 1.0).float() + + self.codebook.data = usage * self.codebook.data + (1 - usage) * code_rand + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + + + return perplexity + + def preprocess(self, x): + # NCT -> NTC -> [NT, C] + x = x.permute(0, 2, 1).contiguous() + x = x.view(-1, x.shape[-1]) + return x + + def quantize(self, x): + # Calculate latent code x_l + k_w = self.codebook.t() + distance = torch.sum(x ** 2, dim=-1, keepdim=True) - 2 * torch.matmul(x, k_w) + torch.sum(k_w ** 2, dim=0, + keepdim=True) # (N * L, b) + _, code_idx = torch.min(distance, dim=-1) + return code_idx + + def dequantize(self, code_idx): + x = F.embedding(code_idx, self.codebook) + return x + + + def forward(self, x): + N, width, T = x.shape + # Preprocess + x = self.preprocess(x) + # Init codebook if not inited + if self.training and not self.init: + self.init_codebook(x) + # quantize and dequantize through bottleneck + code_idx = self.quantize(x) + x_d = self.dequantize(code_idx) + # Update embeddings + if self.training: + perplexity = self.update_codebook(x, code_idx) + else : + perplexity = self.compute_perplexity(code_idx) + + # Loss + commit_loss = F.mse_loss(x, x_d.detach()) + + # Passthrough + x_d = x + (x_d - x).detach() + + # Postprocess + x_d = x_d.view(N, T, -1).permute(0, 2, 1).contiguous() #(N, DIM, T) + + return x_d, commit_loss, perplexity + + +class QuantizeEMA(nn.Module): + def __init__(self, nb_code, code_dim, args): + super().__init__() + self.nb_code = nb_code + self.code_dim = code_dim + self.mu = 0.99 + self.reset_codebook() + + def reset_codebook(self): + self.init = False + self.code_sum = None + self.code_count = None + self.register_buffer('codebook', torch.zeros(self.nb_code, self.code_dim).cuda()) + + def _tile(self, x): + nb_code_x, code_dim = x.shape + if nb_code_x < self.nb_code: + n_repeats = (self.nb_code + nb_code_x - 1) // nb_code_x + std = 0.01 / np.sqrt(code_dim) + out = x.repeat(n_repeats, 1) + out = out + torch.randn_like(out) * std + else : + out = x + return out + + def init_codebook(self, x): + out = self._tile(x) + self.codebook = out[:self.nb_code] + self.code_sum = self.codebook.clone() + self.code_count = torch.ones(self.nb_code, device=self.codebook.device) + self.init = True + + @torch.no_grad() + def compute_perplexity(self, code_idx) : + # Calculate new centres + code_onehot = torch.zeros(self.nb_code, code_idx.shape[0], device=code_idx.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, code_idx.shape[0]), 1) + + code_count = code_onehot.sum(dim=-1) # nb_code + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + return perplexity + + @torch.no_grad() + def update_codebook(self, x, code_idx): + + code_onehot = torch.zeros(self.nb_code, x.shape[0], device=x.device) # nb_code, N * L + code_onehot.scatter_(0, code_idx.view(1, x.shape[0]), 1) + + code_sum = torch.matmul(code_onehot, x) # nb_code, w + code_count = code_onehot.sum(dim=-1) # nb_code + + # Update centres + self.code_sum = self.mu * self.code_sum + (1. - self.mu) * code_sum # w, nb_code + self.code_count = self.mu * self.code_count + (1. - self.mu) * code_count # nb_code + + code_update = self.code_sum.view(self.nb_code, self.code_dim) / self.code_count.view(self.nb_code, 1) + + self.codebook = code_update + prob = code_count / torch.sum(code_count) + perplexity = torch.exp(-torch.sum(prob * torch.log(prob + 1e-7))) + + return perplexity + + def preprocess(self, x): + # NCT -> NTC -> [NT, C] + x = x.permute(0, 2, 1).contiguous() + x = x.view(-1, x.shape[-1]) + return x + + def quantize(self, x): + # Calculate latent code x_l + k_w = self.codebook.t() + distance = torch.sum(x ** 2, dim=-1, keepdim=True) - 2 * torch.matmul(x, k_w) + torch.sum(k_w ** 2, dim=0, + keepdim=True) # (N * L, b) + _, code_idx = torch.min(distance, dim=-1) + return code_idx + + def dequantize(self, code_idx): + x = F.embedding(code_idx, self.codebook) + return x + + + def forward(self, x): + N, width, T = x.shape + + # Preprocess + x = self.preprocess(x) + + # Init codebook if not inited + if self.training and not self.init: + self.init_codebook(x) + + # quantize and dequantize through bottleneck + code_idx = self.quantize(x) + x_d = self.dequantize(code_idx) + + # Update embeddings + if self.training: + perplexity = self.update_codebook(x, code_idx) + else : + perplexity = self.compute_perplexity(code_idx) + + # Loss + commit_loss = F.mse_loss(x, x_d.detach()) + + # Passthrough + x_d = x + (x_d - x).detach() + + # Postprocess + x_d = x_d.view(N, T, -1).permute(0, 2, 1).contiguous() #(N, DIM, T) + + return x_d, commit_loss, perplexity diff --git a/MuseV/MMCM/mmcm/t2p/models/resnet.py b/MuseV/MMCM/mmcm/t2p/models/resnet.py new file mode 100755 index 0000000000000000000000000000000000000000..062346e3ba2fc4d6ae5636f228c5b7565bdb62b7 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/resnet.py @@ -0,0 +1,82 @@ +import torch.nn as nn +import torch + +class nonlinearity(nn.Module): + def __init__(self): + super().__init__() + + def forward(self, x): + # swish + return x * torch.sigmoid(x) + +class ResConv1DBlock(nn.Module): + def __init__(self, n_in, n_state, dilation=1, activation='silu', norm=None, dropout=None): + super().__init__() + padding = dilation + self.norm = norm + if norm == "LN": + self.norm1 = nn.LayerNorm(n_in) + self.norm2 = nn.LayerNorm(n_in) + elif norm == "GN": + self.norm1 = nn.GroupNorm(num_groups=32, num_channels=n_in, eps=1e-6, affine=True) + self.norm2 = nn.GroupNorm(num_groups=32, num_channels=n_in, eps=1e-6, affine=True) + elif norm == "BN": + self.norm1 = nn.BatchNorm1d(num_features=n_in, eps=1e-6, affine=True) + self.norm2 = nn.BatchNorm1d(num_features=n_in, eps=1e-6, affine=True) + + else: + self.norm1 = nn.Identity() + self.norm2 = nn.Identity() + + if activation == "relu": + self.activation1 = nn.ReLU() + self.activation2 = nn.ReLU() + + elif activation == "silu": + self.activation1 = nonlinearity() + self.activation2 = nonlinearity() + + elif activation == "gelu": + self.activation1 = nn.GELU() + self.activation2 = nn.GELU() + + + + self.conv1 = nn.Conv1d(n_in, n_state, 3, 1, padding, dilation) + self.conv2 = nn.Conv1d(n_state, n_in, 1, 1, 0,) + + + def forward(self, x): + x_orig = x + if self.norm == "LN": + x = self.norm1(x.transpose(-2, -1)) + x = self.activation1(x.transpose(-2, -1)) + else: + x = self.norm1(x) + x = self.activation1(x) + + x = self.conv1(x) + + if self.norm == "LN": + x = self.norm2(x.transpose(-2, -1)) + x = self.activation2(x.transpose(-2, -1)) + else: + x = self.norm2(x) + x = self.activation2(x) + + x = self.conv2(x) + x = x + x_orig + return x + +class Resnet1D(nn.Module): + def __init__(self, n_in, n_depth, dilation_growth_rate=1, reverse_dilation=True, activation='relu', norm=None): + super().__init__() + + blocks = [ResConv1DBlock(n_in, n_in, dilation=dilation_growth_rate ** depth, activation=activation, norm=norm) for depth in range(n_depth)] + if reverse_dilation: + blocks = blocks[::-1] + + self.model = nn.Sequential(*blocks) + + def forward(self, x): + return self.model(x) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/models/rotation2xyz.py b/MuseV/MMCM/mmcm/t2p/models/rotation2xyz.py new file mode 100755 index 0000000000000000000000000000000000000000..9901f39909b3c29fb70a17c9471c1b02b81c7efc --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/rotation2xyz.py @@ -0,0 +1,92 @@ +# This code is based on https://github.com/Mathux/ACTOR.git +import torch +from ..utils import rotation_conversions as geometry + + +from ..models.smpl import SMPL, JOINTSTYPE_ROOT +# from .get_model import JOINTSTYPES +JOINTSTYPES = ["a2m", "a2mpl", "smpl", "vibe", "vertices"] + + +class Rotation2xyz: + def __init__(self, device, dataset='amass'): + self.device = device + self.dataset = dataset + self.smpl_model = SMPL().eval().to(device) + + def __call__(self, x, mask, pose_rep, translation, glob, + jointstype, vertstrans, betas=None, beta=0, + glob_rot=None, get_rotations_back=False, **kwargs): + if pose_rep == "xyz": + return x + + if mask is None: + mask = torch.ones((x.shape[0], x.shape[-1]), dtype=bool, device=x.device) + + if not glob and glob_rot is None: + raise TypeError("You must specify global rotation if glob is False") + + if jointstype not in JOINTSTYPES: + raise NotImplementedError("This jointstype is not implemented.") + + if translation: + x_translations = x[:, -1, :3] + x_rotations = x[:, :-1] + else: + x_rotations = x + + x_rotations = x_rotations.permute(0, 3, 1, 2) + nsamples, time, njoints, feats = x_rotations.shape + + # Compute rotations (convert only masked sequences output) + if pose_rep == "rotvec": + rotations = geometry.axis_angle_to_matrix(x_rotations[mask]) + elif pose_rep == "rotmat": + rotations = x_rotations[mask].view(-1, njoints, 3, 3) + elif pose_rep == "rotquat": + rotations = geometry.quaternion_to_matrix(x_rotations[mask]) + elif pose_rep == "rot6d": + rotations = geometry.rotation_6d_to_matrix(x_rotations[mask]) + else: + raise NotImplementedError("No geometry for this one.") + + if not glob: + global_orient = torch.tensor(glob_rot, device=x.device) + global_orient = geometry.axis_angle_to_matrix(global_orient).view(1, 1, 3, 3) + global_orient = global_orient.repeat(len(rotations), 1, 1, 1) + else: + global_orient = rotations[:, 0] + rotations = rotations[:, 1:] + + if betas is None: + betas = torch.zeros([rotations.shape[0], self.smpl_model.num_betas], + dtype=rotations.dtype, device=rotations.device) + betas[:, 1] = beta + # import ipdb; ipdb.set_trace() + out = self.smpl_model(body_pose=rotations, global_orient=global_orient, betas=betas) + + # get the desirable joints + joints = out[jointstype] + + x_xyz = torch.empty(nsamples, time, joints.shape[1], 3, device=x.device, dtype=x.dtype) + x_xyz[~mask] = 0 + x_xyz[mask] = joints + + x_xyz = x_xyz.permute(0, 2, 3, 1).contiguous() + + # the first translation root at the origin on the prediction + if jointstype != "vertices": + rootindex = JOINTSTYPE_ROOT[jointstype] + x_xyz = x_xyz - x_xyz[:, [rootindex], :, :] + + if translation and vertstrans: + # the first translation root at the origin + x_translations = x_translations - x_translations[:, :, [0]] + + # add the translation to all the joints + x_xyz = x_xyz + x_translations[:, None, :, :] + + if get_rotations_back: + return x_xyz, rotations, global_orient + else: + return x_xyz diff --git a/MuseV/MMCM/mmcm/t2p/models/smpl.py b/MuseV/MMCM/mmcm/t2p/models/smpl.py new file mode 100755 index 0000000000000000000000000000000000000000..2ca7dbbafb8d1c4d507dbb3d18239cef54dc4c01 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/smpl.py @@ -0,0 +1,97 @@ +# This code is based on https://github.com/Mathux/ACTOR.git +import numpy as np +import torch + +import contextlib + +from smplx import SMPLLayer as _SMPLLayer +from smplx.lbs import vertices2joints + + +# action2motion_joints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 21, 24, 38] +# change 0 and 8 +action2motion_joints = [8, 1, 2, 3, 4, 5, 6, 7, 0, 9, 10, 11, 12, 13, 14, 21, 24, 38] + +from ..utils.config import SMPL_MODEL_PATH, JOINT_REGRESSOR_TRAIN_EXTRA + +JOINTSTYPE_ROOT = {"a2m": 0, # action2motion + "smpl": 0, + "a2mpl": 0, # set(smpl, a2m) + "vibe": 8} # 0 is the 8 position: OP MidHip below + +JOINT_MAP = { + 'OP Nose': 24, 'OP Neck': 12, 'OP RShoulder': 17, + 'OP RElbow': 19, 'OP RWrist': 21, 'OP LShoulder': 16, + 'OP LElbow': 18, 'OP LWrist': 20, 'OP MidHip': 0, + 'OP RHip': 2, 'OP RKnee': 5, 'OP RAnkle': 8, + 'OP LHip': 1, 'OP LKnee': 4, 'OP LAnkle': 7, + 'OP REye': 25, 'OP LEye': 26, 'OP REar': 27, + 'OP LEar': 28, 'OP LBigToe': 29, 'OP LSmallToe': 30, + 'OP LHeel': 31, 'OP RBigToe': 32, 'OP RSmallToe': 33, 'OP RHeel': 34, + 'Right Ankle': 8, 'Right Knee': 5, 'Right Hip': 45, + 'Left Hip': 46, 'Left Knee': 4, 'Left Ankle': 7, + 'Right Wrist': 21, 'Right Elbow': 19, 'Right Shoulder': 17, + 'Left Shoulder': 16, 'Left Elbow': 18, 'Left Wrist': 20, + 'Neck (LSP)': 47, 'Top of Head (LSP)': 48, + 'Pelvis (MPII)': 49, 'Thorax (MPII)': 50, + 'Spine (H36M)': 51, 'Jaw (H36M)': 52, + 'Head (H36M)': 53, 'Nose': 24, 'Left Eye': 26, + 'Right Eye': 25, 'Left Ear': 28, 'Right Ear': 27 +} + +JOINT_NAMES = [ + 'OP Nose', 'OP Neck', 'OP RShoulder', + 'OP RElbow', 'OP RWrist', 'OP LShoulder', + 'OP LElbow', 'OP LWrist', 'OP MidHip', + 'OP RHip', 'OP RKnee', 'OP RAnkle', + 'OP LHip', 'OP LKnee', 'OP LAnkle', + 'OP REye', 'OP LEye', 'OP REar', + 'OP LEar', 'OP LBigToe', 'OP LSmallToe', + 'OP LHeel', 'OP RBigToe', 'OP RSmallToe', 'OP RHeel', + 'Right Ankle', 'Right Knee', 'Right Hip', + 'Left Hip', 'Left Knee', 'Left Ankle', + 'Right Wrist', 'Right Elbow', 'Right Shoulder', + 'Left Shoulder', 'Left Elbow', 'Left Wrist', + 'Neck (LSP)', 'Top of Head (LSP)', + 'Pelvis (MPII)', 'Thorax (MPII)', + 'Spine (H36M)', 'Jaw (H36M)', + 'Head (H36M)', 'Nose', 'Left Eye', + 'Right Eye', 'Left Ear', 'Right Ear' +] + + +# adapted from VIBE/SPIN to output smpl_joints, vibe joints and action2motion joints +class SMPL(_SMPLLayer): + """ Extension of the official SMPL implementation to support more joints """ + + def __init__(self, model_path=SMPL_MODEL_PATH, **kwargs): + kwargs["model_path"] = model_path + + # remove the verbosity for the 10-shapes beta parameters + with contextlib.redirect_stdout(None): + super(SMPL, self).__init__(**kwargs) + + J_regressor_extra = np.load(JOINT_REGRESSOR_TRAIN_EXTRA) + self.register_buffer('J_regressor_extra', torch.tensor(J_regressor_extra, dtype=torch.float32)) + vibe_indexes = np.array([JOINT_MAP[i] for i in JOINT_NAMES]) + a2m_indexes = vibe_indexes[action2motion_joints] + smpl_indexes = np.arange(24) + a2mpl_indexes = np.unique(np.r_[smpl_indexes, a2m_indexes]) + + self.maps = {"vibe": vibe_indexes, + "a2m": a2m_indexes, + "smpl": smpl_indexes, + "a2mpl": a2mpl_indexes} + + def forward(self, *args, **kwargs): + smpl_output = super(SMPL, self).forward(*args, **kwargs) + + extra_joints = vertices2joints(self.J_regressor_extra, smpl_output.vertices) + all_joints = torch.cat([smpl_output.joints, extra_joints], dim=1) + + output = {"vertices": smpl_output.vertices} + + for joinstype, indexes in self.maps.items(): + output[joinstype] = all_joints[:, indexes] + + return output \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/models/t2m_trans.py b/MuseV/MMCM/mmcm/t2p/models/t2m_trans.py new file mode 100755 index 0000000000000000000000000000000000000000..85b6d618f44f294539c0bfe666a98d9b616ee6d0 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/t2m_trans.py @@ -0,0 +1,211 @@ +import math +import torch +import torch.nn as nn +from torch.nn import functional as F +from torch.distributions import Categorical +from . import pos_encoding as pos_encoding + +class Text2Motion_Transformer(nn.Module): + + def __init__(self, + num_vq=1024, + embed_dim=512, + clip_dim=512, + block_size=16, + num_layers=2, + n_head=8, + drop_out_rate=0.1, + fc_rate=4): + super().__init__() + self.trans_base = CrossCondTransBase(num_vq, embed_dim, clip_dim, block_size, num_layers, n_head, drop_out_rate, fc_rate) + self.trans_head = CrossCondTransHead(num_vq, embed_dim, block_size, num_layers, n_head, drop_out_rate, fc_rate) + self.block_size = block_size + self.num_vq = num_vq + + def get_block_size(self): + return self.block_size + + def forward(self, idxs, clip_feature): + feat = self.trans_base(idxs, clip_feature) + logits = self.trans_head(feat) + return logits + + def sample(self, clip_feature, if_categorial=False): + for k in range(self.block_size): + if k == 0: + x = [] + else: + x = xs + logits = self.forward(x, clip_feature) + logits = logits[:, -1, :] + probs = F.softmax(logits, dim=-1) + if if_categorial: + dist = Categorical(probs) + idx = dist.sample() + if idx == self.num_vq: + break + idx = idx.unsqueeze(-1) + else: + _, idx = torch.topk(probs, k=1, dim=-1) + if idx[0] == self.num_vq: + break + # append to the sequence and continue + if k == 0: + xs = idx + else: + xs = torch.cat((xs, idx), dim=1) + + if k == self.block_size - 1: + return xs[:, :-1] + return xs + +class CausalCrossConditionalSelfAttention(nn.Module): + + def __init__(self, embed_dim=512, block_size=16, n_head=8, drop_out_rate=0.1): + super().__init__() + assert embed_dim % 8 == 0 + # key, query, value projections for all heads + self.key = nn.Linear(embed_dim, embed_dim) + self.query = nn.Linear(embed_dim, embed_dim) + self.value = nn.Linear(embed_dim, embed_dim) + + self.attn_drop = nn.Dropout(drop_out_rate) + self.resid_drop = nn.Dropout(drop_out_rate) + + self.proj = nn.Linear(embed_dim, embed_dim) + # causal mask to ensure that attention is only applied to the left in the input sequence + self.register_buffer("mask", torch.tril(torch.ones(block_size, block_size)).view(1, 1, block_size, block_size)) + self.n_head = n_head + + def forward(self, x): + B, T, C = x.size() + + # calculate query, key, values for all heads in batch and move head forward to be the batch dim + k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs) + # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T) + att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) + att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf')) + att = F.softmax(att, dim=-1) + att = self.attn_drop(att) + y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs) + y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side + + # output projection + y = self.resid_drop(self.proj(y)) + return y + +class Block(nn.Module): + + def __init__(self, embed_dim=512, block_size=16, n_head=8, drop_out_rate=0.1, fc_rate=4): + super().__init__() + self.ln1 = nn.LayerNorm(embed_dim) + self.ln2 = nn.LayerNorm(embed_dim) + self.attn = CausalCrossConditionalSelfAttention(embed_dim, block_size, n_head, drop_out_rate) + self.mlp = nn.Sequential( + nn.Linear(embed_dim, fc_rate * embed_dim), + nn.GELU(), + nn.Linear(fc_rate * embed_dim, embed_dim), + nn.Dropout(drop_out_rate), + ) + + def forward(self, x): + x = x + self.attn(self.ln1(x)) + x = x + self.mlp(self.ln2(x)) + return x + +class CrossCondTransBase(nn.Module): + + def __init__(self, + num_vq=1024, + embed_dim=512, + clip_dim=512, + block_size=16, + num_layers=2, + n_head=8, + drop_out_rate=0.1, + fc_rate=4): + super().__init__() + self.tok_emb = nn.Embedding(num_vq + 2, embed_dim) + self.cond_emb = nn.Linear(clip_dim, embed_dim) + self.pos_embedding = nn.Embedding(block_size, embed_dim) + self.drop = nn.Dropout(drop_out_rate) + # transformer block + self.blocks = nn.Sequential(*[Block(embed_dim, block_size, n_head, drop_out_rate, fc_rate) for _ in range(num_layers)]) + self.pos_embed = pos_encoding.PositionEmbedding(block_size, embed_dim, 0.0, False) + + self.block_size = block_size + + self.apply(self._init_weights) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, idx, clip_feature): + if len(idx) == 0: + token_embeddings = self.cond_emb(clip_feature).unsqueeze(1) + else: + b, t = idx.size() + assert t <= self.block_size, "Cannot forward, model block size is exhausted." + # forward the Trans model + token_embeddings = self.tok_emb(idx) + token_embeddings = torch.cat([self.cond_emb(clip_feature).unsqueeze(1), token_embeddings], dim=1) + + x = self.pos_embed(token_embeddings) + x = self.blocks(x) + + return x + + +class CrossCondTransHead(nn.Module): + + def __init__(self, + num_vq=1024, + embed_dim=512, + block_size=16, + num_layers=2, + n_head=8, + drop_out_rate=0.1, + fc_rate=4): + super().__init__() + + self.blocks = nn.Sequential(*[Block(embed_dim, block_size, n_head, drop_out_rate, fc_rate) for _ in range(num_layers)]) + self.ln_f = nn.LayerNorm(embed_dim) + self.head = nn.Linear(embed_dim, num_vq + 1, bias=False) + self.block_size = block_size + + self.apply(self._init_weights) + + def get_block_size(self): + return self.block_size + + def _init_weights(self, module): + if isinstance(module, (nn.Linear, nn.Embedding)): + module.weight.data.normal_(mean=0.0, std=0.02) + if isinstance(module, nn.Linear) and module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.LayerNorm): + module.bias.data.zero_() + module.weight.data.fill_(1.0) + + def forward(self, x): + x = self.blocks(x) + x = self.ln_f(x) + logits = self.head(x) + return logits + + + + + + diff --git a/MuseV/MMCM/mmcm/t2p/models/vqvae.py b/MuseV/MMCM/mmcm/t2p/models/vqvae.py new file mode 100755 index 0000000000000000000000000000000000000000..6faf66cebcf34187084a3b9ac89fa2c302b16883 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/models/vqvae.py @@ -0,0 +1,118 @@ +import torch.nn as nn +from .encdec import Encoder, Decoder +from .quantize_cnn import QuantizeEMAReset, Quantizer, QuantizeEMA, QuantizeReset + + +class VQVAE_251(nn.Module): + def __init__(self, + args, + nb_code=1024, + code_dim=512, + output_emb_width=512, + down_t=3, + stride_t=2, + width=512, + depth=3, + dilation_growth_rate=3, + activation='relu', + norm=None): + + super().__init__() + self.code_dim = code_dim + self.num_code = nb_code + self.quant = args.quantizer + self.encoder = Encoder(251 if args.dataname == 'kit' else 263, output_emb_width, down_t, stride_t, width, depth, dilation_growth_rate, activation=activation, norm=norm) + self.decoder = Decoder(251 if args.dataname == 'kit' else 263, output_emb_width, down_t, stride_t, width, depth, dilation_growth_rate, activation=activation, norm=norm) + if args.quantizer == "ema_reset": + self.quantizer = QuantizeEMAReset(nb_code, code_dim, args) + elif args.quantizer == "orig": + self.quantizer = Quantizer(nb_code, code_dim, 1.0) + elif args.quantizer == "ema": + self.quantizer = QuantizeEMA(nb_code, code_dim, args) + elif args.quantizer == "reset": + self.quantizer = QuantizeReset(nb_code, code_dim, args) + + + def preprocess(self, x): + # (bs, T, Jx3) -> (bs, Jx3, T) + x = x.permute(0,2,1).float() + return x + + + def postprocess(self, x): + # (bs, Jx3, T) -> (bs, T, Jx3) + x = x.permute(0,2,1) + return x + + + def encode(self, x): + N, T, _ = x.shape + x_in = self.preprocess(x) + x_encoder = self.encoder(x_in) + x_encoder = self.postprocess(x_encoder) + x_encoder = x_encoder.contiguous().view(-1, x_encoder.shape[-1]) # (NT, C) + code_idx = self.quantizer.quantize(x_encoder) + code_idx = code_idx.view(N, -1) + return code_idx + + + def forward(self, x): + + x_in = self.preprocess(x) + # Encode + x_encoder = self.encoder(x_in) + + ## quantization + x_quantized, loss, perplexity = self.quantizer(x_encoder) + + ## decoder + x_decoder = self.decoder(x_quantized) + x_out = self.postprocess(x_decoder) + return x_out, loss, perplexity + + + def forward_decoder(self, x): + x_d = self.quantizer.dequantize(x) + x_d = x_d.view(1, -1, self.code_dim).permute(0, 2, 1).contiguous() + + # decoder + x_decoder = self.decoder(x_d) + x_out = self.postprocess(x_decoder) + return x_out + + + +class HumanVQVAE(nn.Module): + def __init__(self, + args, + nb_code=512, + code_dim=512, + output_emb_width=512, + down_t=3, + stride_t=2, + width=512, + depth=3, + dilation_growth_rate=3, + activation='relu', + norm=None): + + super().__init__() + + self.nb_joints = 21 if args.dataname == 'kit' else 22 + self.vqvae = VQVAE_251(args, nb_code, code_dim, output_emb_width, down_t, stride_t, width, depth, dilation_growth_rate, activation=activation, norm=norm) + + def encode(self, x): + b, t, c = x.size() + quants = self.vqvae.encode(x) # (N, T) + return quants + + def forward(self, x): + + x_out, loss, perplexity = self.vqvae(x) + + return x_out, loss, perplexity + + def forward_decoder(self, x): + x_out = self.vqvae.forward_decoder(x) + return x_out + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/options/get_eval_option.py b/MuseV/MMCM/mmcm/t2p/options/get_eval_option.py new file mode 100755 index 0000000000000000000000000000000000000000..d0989ba1a8116068753ada2cb1806744e4512447 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/options/get_eval_option.py @@ -0,0 +1,83 @@ +from argparse import Namespace +import re +from os.path import join as pjoin + + +def is_float(numStr): + flag = False + numStr = str(numStr).strip().lstrip('-').lstrip('+') + try: + reg = re.compile(r'^[-+]?[0-9]+\.[0-9]+$') + res = reg.match(str(numStr)) + if res: + flag = True + except Exception as ex: + print("is_float() - error: " + str(ex)) + return flag + + +def is_number(numStr): + flag = False + numStr = str(numStr).strip().lstrip('-').lstrip('+') + if str(numStr).isdigit(): + flag = True + return flag + + +def get_opt(opt_path, device): + opt = Namespace() + opt_dict = vars(opt) + + skip = ('-------------- End ----------------', + '------------ Options -------------', + '\n') + print('Reading', opt_path) + with open(opt_path) as f: + for line in f: + if line.strip() not in skip: + # print(line.strip()) + key, value = line.strip().split(': ') + if value in ('True', 'False'): + opt_dict[key] = (value == 'True') + # print(key, value) + elif is_float(value): + opt_dict[key] = float(value) + elif is_number(value): + opt_dict[key] = int(value) + else: + opt_dict[key] = str(value) + + # print(opt) + opt_dict['which_epoch'] = 'finest' + opt.save_root = pjoin(opt.checkpoints_dir, opt.dataset_name, opt.name) + opt.model_dir = pjoin(opt.save_root, 'model') + opt.meta_dir = pjoin(opt.save_root, 'meta') + + if opt.dataset_name == 't2m': + opt.data_root = './dataset/HumanML3D/' + opt.motion_dir = pjoin(opt.data_root, 'new_joint_vecs') + opt.text_dir = pjoin(opt.data_root, 'texts') + opt.joints_num = 22 + opt.dim_pose = 263 + opt.max_motion_length = 196 + opt.max_motion_frame = 196 + opt.max_motion_token = 55 + elif opt.dataset_name == 'kit': + opt.data_root = './dataset/KIT-ML/' + opt.motion_dir = pjoin(opt.data_root, 'new_joint_vecs') + opt.text_dir = pjoin(opt.data_root, 'texts') + opt.joints_num = 21 + opt.dim_pose = 251 + opt.max_motion_length = 196 + opt.max_motion_frame = 196 + opt.max_motion_token = 55 + else: + raise KeyError('Dataset not recognized') + + opt.dim_word = 300 + opt.num_classes = 200 // opt.unit_length + opt.is_train = False + opt.is_continue = False + opt.device = device + + return opt \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/options/option_transformer.py b/MuseV/MMCM/mmcm/t2p/options/option_transformer.py new file mode 100755 index 0000000000000000000000000000000000000000..cf48ce1fdac663ec44419d67721ac268806f8127 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/options/option_transformer.py @@ -0,0 +1,68 @@ +import argparse + +def get_args_parser(): + parser = argparse.ArgumentParser(description='Optimal Transport AutoEncoder training for Amass', + add_help=True, + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + ## dataloader + + parser.add_argument('--dataname', type=str, default='kit', help='dataset directory') + parser.add_argument('--batch-size', default=128, type=int, help='batch size') + parser.add_argument('--fps', default=[20], nargs="+", type=int, help='frames per second') + parser.add_argument('--seq-len', type=int, default=64, help='training motion length') + + ## optimization + parser.add_argument('--total-iter', default=100000, type=int, help='number of total iterations to run') + parser.add_argument('--warm-up-iter', default=1000, type=int, help='number of total iterations for warmup') + parser.add_argument('--lr', default=2e-4, type=float, help='max learning rate') + parser.add_argument('--lr-scheduler', default=[60000], nargs="+", type=int, help="learning rate schedule (iterations)") + parser.add_argument('--gamma', default=0.05, type=float, help="learning rate decay") + + parser.add_argument('--weight-decay', default=1e-6, type=float, help='weight decay') + parser.add_argument('--decay-option',default='all', type=str, choices=['all', 'noVQ'], help='disable weight decay on codebook') + parser.add_argument('--optimizer',default='adamw', type=str, choices=['adam', 'adamw'], help='disable weight decay on codebook') + + ## vqvae arch + parser.add_argument("--code-dim", type=int, default=512, help="embedding dimension") + parser.add_argument("--nb-code", type=int, default=512, help="nb of embedding") + parser.add_argument("--mu", type=float, default=0.99, help="exponential moving average to update the codebook") + parser.add_argument("--down-t", type=int, default=3, help="downsampling rate") + parser.add_argument("--stride-t", type=int, default=2, help="stride size") + parser.add_argument("--width", type=int, default=512, help="width of the network") + parser.add_argument("--depth", type=int, default=3, help="depth of the network") + parser.add_argument("--dilation-growth-rate", type=int, default=3, help="dilation growth rate") + parser.add_argument("--output-emb-width", type=int, default=512, help="output embedding width") + parser.add_argument('--vq-act', type=str, default='relu', choices = ['relu', 'silu', 'gelu'], help='dataset directory') + + ## gpt arch + parser.add_argument("--block-size", type=int, default=25, help="seq len") + parser.add_argument("--embed-dim-gpt", type=int, default=512, help="embedding dimension") + parser.add_argument("--clip-dim", type=int, default=512, help="latent dimension in the clip feature") + parser.add_argument("--num-layers", type=int, default=2, help="nb of transformer layers") + parser.add_argument("--n-head-gpt", type=int, default=8, help="nb of heads") + parser.add_argument("--ff-rate", type=int, default=4, help="feedforward size") + parser.add_argument("--drop-out-rate", type=float, default=0.1, help="dropout ratio in the pos encoding") + + ## quantizer + parser.add_argument("--quantizer", type=str, default='ema_reset', choices = ['ema', 'orig', 'ema_reset', 'reset'], help="eps for optimal transport") + parser.add_argument('--quantbeta', type=float, default=1.0, help='dataset directory') + + ## resume + parser.add_argument("--resume-pth", type=str, default=None, help='resume vq pth') + parser.add_argument("--resume-trans", type=str, default=None, help='resume gpt pth') + + + ## output directory + parser.add_argument('--out-dir', type=str, default='output_GPT_Final/', help='output directory') + parser.add_argument('--exp-name', type=str, default='exp_debug', help='name of the experiment, will create a file inside out-dir') + parser.add_argument('--vq-name', type=str, default='exp_debug', help='name of the generated dataset .npy, will create a file inside out-dir') + ## other + parser.add_argument('--print-iter', default=200, type=int, help='print frequency') + parser.add_argument('--eval-iter', default=5000, type=int, help='evaluation frequency') + parser.add_argument('--seed', default=123, type=int, help='seed for initializing training. ') + parser.add_argument("--if-maxtest", action='store_true', help="test in max") + parser.add_argument('--pkeep', type=float, default=1.0, help='keep rate for gpt training') + + + return parser.parse_args() \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/options/option_vq.py b/MuseV/MMCM/mmcm/t2p/options/option_vq.py new file mode 100755 index 0000000000000000000000000000000000000000..08a53ff1270facc10ab44ec0647e673ed1336d0d --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/options/option_vq.py @@ -0,0 +1,61 @@ +import argparse + +def get_args_parser(): + parser = argparse.ArgumentParser(description='Optimal Transport AutoEncoder training for AIST', + add_help=True, + formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + ## dataloader + parser.add_argument('--dataname', type=str, default='kit', help='dataset directory') + parser.add_argument('--batch-size', default=128, type=int, help='batch size') + parser.add_argument('--window-size', type=int, default=64, help='training motion length') + + ## optimization + parser.add_argument('--total-iter', default=200000, type=int, help='number of total iterations to run') + parser.add_argument('--warm-up-iter', default=1000, type=int, help='number of total iterations for warmup') + parser.add_argument('--lr', default=2e-4, type=float, help='max learning rate') + parser.add_argument('--lr-scheduler', default=[50000, 400000], nargs="+", type=int, help="learning rate schedule (iterations)") + parser.add_argument('--gamma', default=0.05, type=float, help="learning rate decay") + + parser.add_argument('--weight-decay', default=0.0, type=float, help='weight decay') + parser.add_argument("--commit", type=float, default=0.02, help="hyper-parameter for the commitment loss") + parser.add_argument('--loss-vel', type=float, default=0.1, help='hyper-parameter for the velocity loss') + parser.add_argument('--recons-loss', type=str, default='l2', help='reconstruction loss') + + ## vqvae arch + parser.add_argument("--code-dim", type=int, default=512, help="embedding dimension") + parser.add_argument("--nb-code", type=int, default=512, help="nb of embedding") + parser.add_argument("--mu", type=float, default=0.99, help="exponential moving average to update the codebook") + parser.add_argument("--down-t", type=int, default=2, help="downsampling rate") + parser.add_argument("--stride-t", type=int, default=2, help="stride size") + parser.add_argument("--width", type=int, default=512, help="width of the network") + parser.add_argument("--depth", type=int, default=3, help="depth of the network") + parser.add_argument("--dilation-growth-rate", type=int, default=3, help="dilation growth rate") + parser.add_argument("--output-emb-width", type=int, default=512, help="output embedding width") + parser.add_argument('--vq-act', type=str, default='relu', choices = ['relu', 'silu', 'gelu'], help='dataset directory') + parser.add_argument('--vq-norm', type=str, default=None, help='dataset directory') + + ## quantizer + parser.add_argument("--quantizer", type=str, default='ema_reset', choices = ['ema', 'orig', 'ema_reset', 'reset'], help="eps for optimal transport") + parser.add_argument('--beta', type=float, default=1.0, help='commitment loss in standard VQ') + + ## resume + parser.add_argument("--resume-pth", type=str, default=None, help='resume pth for VQ') + parser.add_argument("--resume-gpt", type=str, default=None, help='resume pth for GPT') + + + ## output directory + parser.add_argument('--out-dir', type=str, default='output_vqfinal/', help='output directory') + parser.add_argument('--results-dir', type=str, default='visual_results/', help='output directory') + parser.add_argument('--visual-name', type=str, default='baseline', help='output directory') + parser.add_argument('--exp-name', type=str, default='exp_debug', help='name of the experiment, will create a file inside out-dir') + ## other + parser.add_argument('--print-iter', default=200, type=int, help='print frequency') + parser.add_argument('--eval-iter', default=1000, type=int, help='evaluation frequency') + parser.add_argument('--seed', default=123, type=int, help='seed for initializing training.') + + parser.add_argument('--vis-gt', action='store_true', help='whether visualize GT motions') + parser.add_argument('--nb-vis', default=20, type=int, help='nb of visualizations') + + + return parser.parse_args() \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/render_final.py b/MuseV/MMCM/mmcm/t2p/render_final.py new file mode 100755 index 0000000000000000000000000000000000000000..2665f86ae8c4b49c90fffbe679ee1a3fffc5f64f --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/render_final.py @@ -0,0 +1,194 @@ +from models.rotation2xyz import Rotation2xyz +import numpy as np +from trimesh import Trimesh +import os +os.environ['PYOPENGL_PLATFORM'] = "osmesa" + +import torch +from visualize.simplify_loc2rot import joints2smpl +import pyrender +import matplotlib.pyplot as plt + +import io +import imageio +from shapely import geometry +import trimesh +from pyrender.constants import RenderFlags +import math +# import ffmpeg +from PIL import Image + +class WeakPerspectiveCamera(pyrender.Camera): + def __init__(self, + scale, + translation, + znear=pyrender.camera.DEFAULT_Z_NEAR, + zfar=None, + name=None): + super(WeakPerspectiveCamera, self).__init__( + znear=znear, + zfar=zfar, + name=name, + ) + self.scale = scale + self.translation = translation + + def get_projection_matrix(self, width=None, height=None): + P = np.eye(4) + P[0, 0] = self.scale[0] + P[1, 1] = self.scale[1] + P[0, 3] = self.translation[0] * self.scale[0] + P[1, 3] = -self.translation[1] * self.scale[1] + P[2, 2] = -1 + return P + +def render(motions, outdir='test_vis', device_id=0, name=None, pred=True): + frames, njoints, nfeats = motions.shape + MINS = motions.min(axis=0).min(axis=0) + MAXS = motions.max(axis=0).max(axis=0) + + height_offset = MINS[1] + motions[:, :, 1] -= height_offset + trajec = motions[:, 0, [0, 2]] + + j2s = joints2smpl(num_frames=frames, device_id=0, cuda=True) + rot2xyz = Rotation2xyz(device=torch.device("cuda:0")) + faces = rot2xyz.smpl_model.faces + + if (not os.path.exists(outdir + name+'_pred.pt') and pred) or (not os.path.exists(outdir + name+'_gt.pt') and not pred): + print(f'Running SMPLify, it may take a few minutes.') + motion_tensor, opt_dict = j2s.joint2smpl(motions) # [nframes, njoints, 3] + + vertices = rot2xyz(torch.tensor(motion_tensor).clone(), mask=None, + pose_rep='rot6d', translation=True, glob=True, + jointstype='vertices', + vertstrans=True) + + if pred: + torch.save(vertices, outdir + name+'_pred.pt') + else: + torch.save(vertices, outdir + name+'_gt.pt') + else: + if pred: + vertices = torch.load(outdir + name+'_pred.pt') + else: + vertices = torch.load(outdir + name+'_gt.pt') + frames = vertices.shape[3] # shape: 1, nb_frames, 3, nb_joints + print (vertices.shape) + MINS = torch.min(torch.min(vertices[0], axis=0)[0], axis=1)[0] + MAXS = torch.max(torch.max(vertices[0], axis=0)[0], axis=1)[0] + # vertices[:,:,1,:] -= MINS[1] + 1e-5 + + + out_list = [] + + minx = MINS[0] - 0.5 + maxx = MAXS[0] + 0.5 + minz = MINS[2] - 0.5 + maxz = MAXS[2] + 0.5 + polygon = geometry.Polygon([[minx, minz], [minx, maxz], [maxx, maxz], [maxx, minz]]) + polygon_mesh = trimesh.creation.extrude_polygon(polygon, 1e-5) + + vid = [] + for i in range(frames): + if i % 10 == 0: + print(i) + + mesh = Trimesh(vertices=vertices[0, :, :, i].squeeze().tolist(), faces=faces) + + base_color = (0.11, 0.53, 0.8, 0.5) + ## OPAQUE rendering without alpha + ## BLEND rendering consider alpha + material = pyrender.MetallicRoughnessMaterial( + metallicFactor=0.7, + alphaMode='OPAQUE', + baseColorFactor=base_color + ) + + + mesh = pyrender.Mesh.from_trimesh(mesh, material=material) + + polygon_mesh.visual.face_colors = [0, 0, 0, 0.21] + polygon_render = pyrender.Mesh.from_trimesh(polygon_mesh, smooth=False) + + bg_color = [1, 1, 1, 0.8] + scene = pyrender.Scene(bg_color=bg_color, ambient_light=(0.4, 0.4, 0.4)) + + sx, sy, tx, ty = [0.75, 0.75, 0, 0.10] + + camera = pyrender.PerspectiveCamera(yfov=(np.pi / 3.0)) + + light = pyrender.DirectionalLight(color=[1,1,1], intensity=300) + + scene.add(mesh) + + c = np.pi / 2 + + scene.add(polygon_render, pose=np.array([[ 1, 0, 0, 0], + + [ 0, np.cos(c), -np.sin(c), MINS[1].cpu().numpy()], + + [ 0, np.sin(c), np.cos(c), 0], + + [ 0, 0, 0, 1]])) + + light_pose = np.eye(4) + light_pose[:3, 3] = [0, -1, 1] + scene.add(light, pose=light_pose.copy()) + + light_pose[:3, 3] = [0, 1, 1] + scene.add(light, pose=light_pose.copy()) + + light_pose[:3, 3] = [1, 1, 2] + scene.add(light, pose=light_pose.copy()) + + + c = -np.pi / 6 + + scene.add(camera, pose=[[ 1, 0, 0, (minx+maxx).cpu().numpy()/2], + + [ 0, np.cos(c), -np.sin(c), 1.5], + + [ 0, np.sin(c), np.cos(c), max(4, minz.cpu().numpy()+(1.5-MINS[1].cpu().numpy())*2, (maxx-minx).cpu().numpy())], + + [ 0, 0, 0, 1] + ]) + + # render scene + r = pyrender.OffscreenRenderer(960, 960) + + color, _ = r.render(scene, flags=RenderFlags.RGBA) + # Image.fromarray(color).save(outdir+name+'_'+str(i)+'.png') + + vid.append(color) + + r.delete() + + out = np.stack(vid, axis=0) + if pred: + imageio.mimsave(outdir + name+'_pred.gif', out, fps=20) + else: + imageio.mimsave(outdir + name+'_gt.gif', out, fps=20) + + + + + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser() + parser.add_argument("--filedir", type=str, default=None, help='motion npy file dir') + parser.add_argument('--motion-list', default=None, nargs="+", type=str, help="motion name list") + args = parser.parse_args() + + filename_list = args.motion_list + filedir = args.filedir + + for filename in filename_list: + motions = np.load(filedir + filename+'_pred.npy') + print('pred', motions.shape, filename) + render(motions[0], outdir=filedir, device_id=0, name=filename, pred=True) + + motions = np.load(filedir + filename+'_gt.npy') + print('gt', motions.shape, filename) + render(motions[0], outdir=filedir, device_id=0, name=filename, pred=False) diff --git a/MuseV/MMCM/mmcm/t2p/smpl.gif b/MuseV/MMCM/mmcm/t2p/smpl.gif new file mode 100755 index 0000000000000000000000000000000000000000..2a61d88f1018429cdead2a9bd7902222d0afb57a Binary files /dev/null and b/MuseV/MMCM/mmcm/t2p/smpl.gif differ diff --git a/MuseV/MMCM/mmcm/t2p/text2pose.py b/MuseV/MMCM/mmcm/t2p/text2pose.py new file mode 100755 index 0000000000000000000000000000000000000000..7f671fae8a432aff53808e66cbf185a8e52e7d6f --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/text2pose.py @@ -0,0 +1,359 @@ +#from __future__ import absolute_import +import sys +import io +import os +sys.argv = ['GPT_eval_multi.py'] + +# 将项目根目录添加到sys.path中 +PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(1, PROJECT_ROOT) +CKPT_ROOT="/cfs-datasets/public_models/motion" + +from .options import option_transformer as option_trans + +import sys +print(sys.path[0]) + +import clip +import torch +import cv2 +import numpy as np +from .models import vqvae as vqvae +from .models import t2m_trans as trans +import warnings +from .visualization import plot_3d_global as plot_3d +import matplotlib.pyplot as plt +import numpy as np +import matplotlib.colors as mcolors +from tqdm import tqdm +from mpl_toolkits.mplot3d import Axes3D +from PIL import Image + +import time +import random + + +warnings.filterwarnings('ignore') +from matplotlib.axes._axes import _log as matplotlib_axes_logger +matplotlib_axes_logger.setLevel('ERROR') + +from math import cos,sin,radians + +args = option_trans.get_args_parser() + +args.dataname = 't2m' +args.resume_pth = os.path.join(CKPT_ROOT,'pretrained/VQVAE/net_last.pth') +args.resume_trans = os.path.join(CKPT_ROOT,'pretrained/VQTransformer_corruption05/net_best_fid.pth') +args.down_t = 2 +args.depth = 3 +args.block_size = 51 + +def replace_space_with_underscore(s): + return s.replace(' ', '_') + + +def Rz(angle): + theta=radians(angle) + return np.array([[cos(theta), -sin(theta), 0], + [sin(theta), cos(theta), 0], + [0, 0, 1]]) + + +def Rx(angle): + theta=radians(angle) + return np.array( + [[1, 0, 0], + [0 , cos(theta), -sin(theta)], + [0, sin(theta), cos(theta)]]) + +def generate_cuid(): + timestamp = hex(int(time.time() * 1000))[2:] + random_str = hex(random.randint(0, 0xfffff))[2:] + return (timestamp + random_str).zfill(10) + +def smpl_to_openpose18(smpl_keypoints): + ''' + 22关键点SMPL对应关系解释 + [0, 2, 5, 8, 11] + 这个列表表示SMPL模型中左腿的连接方式，从骨盆（0号关键点）开始，连接左大腿（2号关键点）、左小腿（5号关键点）、左脚（8号关键点）和左脚尖（11号关键点）。 + + [0, 1, 4, 7, 10] + 这个列表表示SMPL模型中右腿的连接方式，从骨盆（0号关键点）开始，连接右大腿（1号关键点）、右小腿（4号关键点）、右脚（7号关键点）和右脚尖（10号关键点）。 + + [0, 3, 6, 9, 12, 15] + 这个列表表示SMPL模型中躯干的连接方式，从骨盆（0号关键点）开始，连接脊柱（3号关键点）、颈部（6号关键点）、头部（9号关键点）、左肩膀（12号关键点）、右肩膀（15号关键点）。 + + [9, 14, 17, 19, 21] + 这个列表表示SMPL模型中左臂的连接方式，从左肩膀（9号关键点）开始，连接左上臂（14号关键点）、左前臂（17号关键点）、左手腕（19号关键点）和左手（21号关键点）。 + + [9, 13, 16, 18, 20] + 这个列表表示SMPL模型中右臂的连接方式，从右肩膀（9号关键点）开始，连接右上臂（13号关键点）、右前臂（16号关键点）、右手腕（18号关键点）和右手（20号关键点）。 + + 目前转Openpose忽略掉了SMPL的肩膀关键点 + ''' + openpose_keypoints = np.zeros((18, 3)) + openpose_keypoints[0] = smpl_keypoints[9] # nose + openpose_keypoints[0][1] = openpose_keypoints[0][1]+0.3 # + + + openpose_keypoints[1] = smpl_keypoints[6] # neck + openpose_keypoints[2] = smpl_keypoints[16] # right shoulder + openpose_keypoints[3] = smpl_keypoints[18] # right elbow + openpose_keypoints[4] = smpl_keypoints[20] # right wrist + openpose_keypoints[5] = smpl_keypoints[17] # left shoulder + openpose_keypoints[6] = smpl_keypoints[19] # left elbow + openpose_keypoints[7] = smpl_keypoints[21] # left wrist + + #TODO: Experiment,将neck的关键点抬高&&将nose的关键点相对高度关系与neck保持一致 + openpose_keypoints[1][0]=(openpose_keypoints[2][0]+openpose_keypoints[5][0])/2 + openpose_keypoints[1][1]=(openpose_keypoints[2][1]+openpose_keypoints[5][1])/2 + openpose_keypoints[1][2]=(openpose_keypoints[2][2]+openpose_keypoints[5][2])/2 + openpose_keypoints[0][1] = openpose_keypoints[1][1]+0.3 # + + + openpose_keypoints[8] = smpl_keypoints[1] # right hip + openpose_keypoints[9] = smpl_keypoints[4] # right knee + openpose_keypoints[10] = smpl_keypoints[7] # right ankle + openpose_keypoints[11] = smpl_keypoints[2] # left hip + openpose_keypoints[12] = smpl_keypoints[5] # left knee + openpose_keypoints[13] = smpl_keypoints[8] # left ankle + + #TODO: Experiment,手工指定脸部关键点测试是否能够指定身体朝向 + #openpose_keypoints[0][0] = openpose_keypoints[0][0]+0.3#测试0坐标轴方向(水平向右) + #openpose_keypoints[0][2] = openpose_keypoints[0][2]#测试2坐标轴方向（向外 + #openpose_keypoints[0][1] = openpose_keypoints[0][1]+0.5#测试1坐标轴方向（垂直向上 + openpose_keypoints[14] = openpose_keypoints[0] # right eye + openpose_keypoints[14][1]=openpose_keypoints[14][1]+0.05 + openpose_keypoints[14][0]=openpose_keypoints[14][0]+0.3*(openpose_keypoints[2][0]-openpose_keypoints[1][0]) + openpose_keypoints[14][2]=openpose_keypoints[14][2]+0.3*(openpose_keypoints[2][2]-openpose_keypoints[1][2]) + + openpose_keypoints[15] = openpose_keypoints[0] # left eye + openpose_keypoints[15][1]=openpose_keypoints[15][1]+0.05 + openpose_keypoints[15][0]=openpose_keypoints[15][0]+0.3*(openpose_keypoints[5][0]-openpose_keypoints[1][0]) + openpose_keypoints[15][2]=openpose_keypoints[15][2]+0.3*(openpose_keypoints[5][2]-openpose_keypoints[1][2]) + + openpose_keypoints[16] = openpose_keypoints[0] # right ear + openpose_keypoints[16][0]=openpose_keypoints[16][0]+0.7*(openpose_keypoints[2][0]-openpose_keypoints[1][0]) + openpose_keypoints[16][2]=openpose_keypoints[16][2]+0.7*(openpose_keypoints[2][2]-openpose_keypoints[1][2]) + + openpose_keypoints[17] = openpose_keypoints[0] # left ear + openpose_keypoints[17][0]=openpose_keypoints[17][0]+0.7*(openpose_keypoints[5][0]-openpose_keypoints[1][0]) + openpose_keypoints[17][2]=openpose_keypoints[17][2]+0.7*(openpose_keypoints[5][2]-openpose_keypoints[1][2]) + + return openpose_keypoints + + + + + + +# TODO: debug only, need to be deleted before unload +## load clip model and datasets +clip_model, clip_preprocess = clip.load("ViT-B/32", device=torch.device('cuda'), jit=False, download_root=CKPT_ROOT) # Must set jit=False for training +clip.model.convert_weights(clip_model) # Actually this line is unnecessary since clip by default already on float16 +clip_model.eval() +for p in clip_model.parameters(): + p.requires_grad = False +print("loaded CLIP model") +net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers + args.nb_code, + args.code_dim, + args.output_emb_width, + args.down_t, + args.stride_t, + args.width, + args.depth, + args.dilation_growth_rate) + + +trans_encoder = trans.Text2Motion_Transformer(num_vq=args.nb_code, + embed_dim=1024, + clip_dim=args.clip_dim, + block_size=args.block_size, + num_layers=9, + n_head=16, + drop_out_rate=args.drop_out_rate, + fc_rate=args.ff_rate) + + +print ('loading checkpoint from {}'.format(args.resume_pth)) +ckpt = torch.load(args.resume_pth, map_location='cpu') +net.load_state_dict(ckpt['net'], strict=True) +net.eval() +net.cuda() + +print ('loading transformer checkpoint from {}'.format(args.resume_trans)) +ckpt = torch.load(args.resume_trans, map_location='cpu') +trans_encoder.load_state_dict(ckpt['trans'], strict=True) +trans_encoder.eval() +trans_encoder.cuda() + +mean = torch.from_numpy(np.load(os.path.join(CKPT_ROOT,'./checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta/mean.npy'))).cuda() +std = torch.from_numpy(np.load(os.path.join(CKPT_ROOT,'./checkpoints/t2m/VQVAEV3_CB1024_CMT_H1024_NRES3/meta/std.npy'))).cuda() + + + +def get_open_pose(text,height,width,save_path,video_length): + CKPT_ROOT = os.path.dirname(os.path.abspath(__file__)) + + clip_text=[text] + print(f"Motion Prompt: {text}") + # cuid=generate_cuid() + # print(f"Motion Generation cuid: {cuid}") + + # clip_text = ["the person jump and spin twice,then running straght and sit down. "] #支持单个token的生成 + + # change the text here + + + + text = clip.tokenize(clip_text, truncate=False).cuda() + feat_clip_text = clip_model.encode_text(text).float() + index_motion = trans_encoder.sample(feat_clip_text[0:1], False) + pred_pose = net.forward_decoder(index_motion) + + from utils.motion_process import recover_from_ric + pred_xyz = recover_from_ric((pred_pose*std+mean).float(), 22) + xyz = pred_xyz.reshape(1, -1, 22, 3) + + np.save('motion.npy', xyz.detach().cpu().numpy()) + + + pose_vis = plot_3d.draw_to_batch(xyz.detach().cpu().numpy(),clip_text, ['smpl.gif']) + + res=xyz.detach().cpu().numpy() + points_3d_list=res[0] + frame_num=points_3d_list.shape[0] + + open_pose_list=np.array(points_3d_list) + print("The total SMPL sequence shape is : "+str(open_pose_list.shape)) + + max_val = np.max(open_pose_list, axis=(0, 1)) + min_val = np.min(open_pose_list, axis=(0, 1)) + + print("三维坐标在坐标系上的最大值：", max_val) + print("三维坐标在坐标系上的最小值：", min_val) + + + check= smpl_to_openpose18(open_pose_list[0]) # 18个关键点 + print("********SMPL_2_OpenPose_List(14/18)********") + print(check) + print("*************************") + print(f"Total Frame Number: {frame_num}") + img_list=[] + for step in tqdm(range(0,frame_num)): + # 生成图像 + dpi=84 + fig =plt.figure(figsize=(width/dpi, height/dpi), dpi=dpi) + ax = fig.add_subplot(111, projection='3d') + limits=2 + + ax.set_xlim(-limits*0.7, limits*0.7) + ax.set_ylim(0, limits*1.5)#上下 + ax.set_zlim(0, limits*1.5)# 前后 + ax.grid(b=False) + #ax.dist = 1 + ax.set_box_aspect([1.4, 1.5, 1.5],zoom=3.5)# 坐标轴比例 TODO:这个比例可能有问题，会出现超出坐标范围的bug + + # 关键点坐标，每行包含(x, y, z) + keypoints = smpl_to_openpose18(open_pose_list[step]) # 18个关键点 + + # 运动学链 目前只用到body部分 + kinematic_chain = [(0, 1), (1, 2), (2, 3), (3, 4), (1, 5), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13), (0, 14), (14, 16), (0, 15), (15, 17)] + #kinematic_chain = [(0, 1), (1, 2), (2, 3), (3, 4), (1, 5), (5, 6), (6, 7), (1, 8), (8, 9), (9, 10), (1, 11), (11, 12), (12, 13)] + + # 颜色RGB + + colors = [(0, 0, 255), (0, 255, 255), (0, 255, 0), (255, 0, 0), (255, 0, 255), (255, 192, 203), (0, 165, 255), (19, 69, 139), (173, 216, 230), (34, 139, 34), (0, 0, 128), (184, 134, 11), (139, 0, 139), (0, 100, 0), (0, 255, 255), (0, 255, 0), (216, 191, 216), (255, 255, 224)] + #colors=[(0, 0, 255), (0, 255, 255), (0, 255, 0), (255, 0, 0), (255, 0, 255), (255, 192, 203), (0, 165, 255), (19, 69, 139), (173, 216, 230), (34, 139, 34), (0, 0, 128), (184, 134, 11), (139, 0, 139), (0, 100, 0)] + + #18点 + joint_colors=[(255,0,0),(255,85,0),(255,170,0),(255,255,0),(170,255,0),(85,255,0),(0,255,0),(0,255,85),(0,255,170),(0,255,255),(0,170,255),(0,85,255),(0,0,255),(85,0,255),(170,0,255),(255,0,255),(255,0,170),(255,0,85),(255,0,0)] + #14点主干 + #joint_colors=[(255,0,0),(255,85,0),(255,170,0),(255,255,0),(170,255,0),(85,255,0),(0,255,0),(0,255,85),(0,255,170),(0,255,255),(0,170,255),(0,85,255),(0,0,255),(85,0,255),(170,0,255)] + #运动链连线是joint颜色的60% + + + #plt颜色在0-1之间 + rgb_color2=[] + joint_rgb_color2=[] + kinematic_chain_rgb_color2=[] + for color in joint_colors: + joint_rgb_color2.append(tuple([x/255 for x in color])) + kinematic_chain_rgb_color2.append(tuple([x*0.6/255 for x in color])) #运动链连线是joint颜色的60% + + # 可视化结果 + for i in range(0,18): + # 绘制关键点 + ax.scatter(keypoints[i][0], keypoints[i][1], keypoints[i][2], s=50, c=joint_rgb_color2[i], marker='o') + + # 绘制运动学链 + for j in range(len(kinematic_chain)): + if kinematic_chain[j][1] == i: + ax.plot([keypoints[kinematic_chain[j][0]][0], keypoints[kinematic_chain[j][1]][0]], [keypoints[kinematic_chain[j][0]][1], keypoints[kinematic_chain[j][1]][1]], [keypoints[kinematic_chain[j][0]][2], keypoints[kinematic_chain[j][1]][2]], c=kinematic_chain_rgb_color2[i], linewidth=5) + + # 调整视角 + ax.view_init(elev=110, azim=-90) + plt.axis('off') + + + # 保存图片 + # 将图像数据输出为图像数组 + if not os.path.exists(save_path): + os.makedirs(save_path) + image_tmp_path=str(f"{save_path}/{str(step)}.jpg") + plt.savefig(os.path.join(CKPT_ROOT,image_tmp_path))#RGB + img=cv2.imread(os.path.join(CKPT_ROOT,image_tmp_path)) + img=cv2.cvtColor(img,cv2.COLOR_BGR2RGB) + img_list.append(img) + res=[] + if len(img_list)>=video_length: + key_frame_sample_step=int(len(img_list)/video_length) + else: + print("ERROR: video length is too long") + key_frame_sample_step=1 + + for i in range(0,len(img_list),key_frame_sample_step): + res.append(img_list[i]) + + return res + + + +def offline_get_open_pose(text,motion_text,height,width,save_path): + #motion_text=text + + clip_text=[text] + print(f"Motion Prompt: {text}") + cuid=generate_cuid() + print(f"Motion Generation cuid: {cuid}") + + # clip_text = ["the person jump and spin twice,then running straght and sit down. "] #支持单个token的生成 + + # change the text here + + + + text = clip.tokenize(clip_text, truncate=False).cuda() + feat_clip_text = clip_model.encode_text(text).float() + index_motion = trans_encoder.sample(feat_clip_text[0:1], False) + pred_pose = net.forward_decoder(index_motion) + + from utils.motion_process import recover_from_ric + pred_xyz = recover_from_ric((pred_pose*std+mean).float(), 22) + xyz = pred_xyz.reshape(1, -1, 22, 3) + res=xyz.detach().cpu().numpy() + np.save(f'{save_path}/{replace_space_with_underscore(motion_text)}.npy', res) + + + pose_vis = plot_3d.draw_to_batch(res,clip_text, ['smpl.gif']) + + + + +if __name__ == "__main__": + + text="walk around, jump, run straght." + pose = get_open_pose(text,512,512) + #pdb.set_trace() + diff --git a/MuseV/MMCM/mmcm/t2p/train_t2m_trans.py b/MuseV/MMCM/mmcm/t2p/train_t2m_trans.py new file mode 100755 index 0000000000000000000000000000000000000000..09df8625c536297e0a335a5c592916d36eb3f8f2 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/train_t2m_trans.py @@ -0,0 +1,191 @@ +import os +import torch +import numpy as np + +from torch.utils.tensorboard import SummaryWriter +from os.path import join as pjoin +from torch.distributions import Categorical +import json +import clip + +import options.option_transformer as option_trans +import models.vqvae as vqvae +import utils.utils_model as utils_model +import utils.eval_trans as eval_trans +from dataset import dataset_TM_train +from dataset import dataset_TM_eval +from dataset import dataset_tokenize +import models.t2m_trans as trans +from options.get_eval_option import get_opt +from models.evaluator_wrapper import EvaluatorModelWrapper +import warnings +warnings.filterwarnings('ignore') + +##### ---- Exp dirs ---- ##### +args = option_trans.get_args_parser() +torch.manual_seed(args.seed) + +args.out_dir = os.path.join(args.out_dir, f'{args.exp_name}') +args.vq_dir= os.path.join("./dataset/KIT-ML" if args.dataname == 'kit' else "./dataset/HumanML3D", f'{args.vq_name}') +os.makedirs(args.out_dir, exist_ok = True) +os.makedirs(args.vq_dir, exist_ok = True) + +##### ---- Logger ---- ##### +logger = utils_model.get_logger(args.out_dir) +writer = SummaryWriter(args.out_dir) +logger.info(json.dumps(vars(args), indent=4, sort_keys=True)) + +##### ---- Dataloader ---- ##### +train_loader_token = dataset_tokenize.DATALoader(args.dataname, 1, unit_length=2**args.down_t) + +from utils.word_vectorizer import WordVectorizer +w_vectorizer = WordVectorizer('./glove', 'our_vab') +val_loader = dataset_TM_eval.DATALoader(args.dataname, False, 32, w_vectorizer) + +dataset_opt_path = 'checkpoints/kit/Comp_v6_KLD005/opt.txt' if args.dataname == 'kit' else 'checkpoints/t2m/Comp_v6_KLD005/opt.txt' + +wrapper_opt = get_opt(dataset_opt_path, torch.device('cuda')) +eval_wrapper = EvaluatorModelWrapper(wrapper_opt) + +##### ---- Network ---- ##### +clip_model, clip_preprocess = clip.load("ViT-B/32", device=torch.device('cuda'), jit=False) # Must set jit=False for training +clip.model.convert_weights(clip_model) # Actually this line is unnecessary since clip by default already on float16 +clip_model.eval() +for p in clip_model.parameters(): + p.requires_grad = False + +net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers + args.nb_code, + args.code_dim, + args.output_emb_width, + args.down_t, + args.stride_t, + args.width, + args.depth, + args.dilation_growth_rate) + + +trans_encoder = trans.Text2Motion_Transformer(num_vq=args.nb_code, + embed_dim=args.embed_dim_gpt, + clip_dim=args.clip_dim, + block_size=args.block_size, + num_layers=args.num_layers, + n_head=args.n_head_gpt, + drop_out_rate=args.drop_out_rate, + fc_rate=args.ff_rate) + + +print ('loading checkpoint from {}'.format(args.resume_pth)) +ckpt = torch.load(args.resume_pth, map_location='cpu') +net.load_state_dict(ckpt['net'], strict=True) +net.eval() +net.cuda() + +if args.resume_trans is not None: + print ('loading transformer checkpoint from {}'.format(args.resume_trans)) + ckpt = torch.load(args.resume_trans, map_location='cpu') + trans_encoder.load_state_dict(ckpt['trans'], strict=True) +trans_encoder.train() +trans_encoder.cuda() + +##### ---- Optimizer & Scheduler ---- ##### +optimizer = utils_model.initial_optim(args.decay_option, args.lr, args.weight_decay, trans_encoder, args.optimizer) +scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_scheduler, gamma=args.gamma) + +##### ---- Optimization goals ---- ##### +loss_ce = torch.nn.CrossEntropyLoss() + +nb_iter, avg_loss_cls, avg_acc = 0, 0., 0. +right_num = 0 +nb_sample_train = 0 + +##### ---- get code ---- ##### +for batch in train_loader_token: + pose, name = batch + bs, seq = pose.shape[0], pose.shape[1] + + pose = pose.cuda().float() # bs, nb_joints, joints_dim, seq_len + target = net.encode(pose) + target = target.cpu().numpy() + np.save(pjoin(args.vq_dir, name[0] +'.npy'), target) + + +train_loader = dataset_TM_train.DATALoader(args.dataname, args.batch_size, args.nb_code, args.vq_name, unit_length=2**args.down_t) +train_loader_iter = dataset_TM_train.cycle(train_loader) + + +##### ---- Training ---- ##### +best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger = eval_trans.evaluation_transformer(args.out_dir, val_loader, net, trans_encoder, logger, writer, 0, best_fid=1000, best_iter=0, best_div=100, best_top1=0, best_top2=0, best_top3=0, best_matching=100, clip_model=clip_model, eval_wrapper=eval_wrapper) +while nb_iter <= args.total_iter: + + batch = next(train_loader_iter) + clip_text, m_tokens, m_tokens_len = batch + m_tokens, m_tokens_len = m_tokens.cuda(), m_tokens_len.cuda() + bs = m_tokens.shape[0] + target = m_tokens # (bs, 26) + target = target.cuda() + + text = clip.tokenize(clip_text, truncate=True).cuda() + + feat_clip_text = clip_model.encode_text(text).float() + + input_index = target[:,:-1] + + if args.pkeep == -1: + proba = np.random.rand(1)[0] + mask = torch.bernoulli(proba * torch.ones(input_index.shape, + device=input_index.device)) + else: + mask = torch.bernoulli(args.pkeep * torch.ones(input_index.shape, + device=input_index.device)) + mask = mask.round().to(dtype=torch.int64) + r_indices = torch.randint_like(input_index, args.nb_code) + a_indices = mask*input_index+(1-mask)*r_indices + + cls_pred = trans_encoder(a_indices, feat_clip_text) + cls_pred = cls_pred.contiguous() + + loss_cls = 0.0 + for i in range(bs): + # loss function (26), (26, 513) + loss_cls += loss_ce(cls_pred[i][:m_tokens_len[i] + 1], target[i][:m_tokens_len[i] + 1]) / bs + + # Accuracy + probs = torch.softmax(cls_pred[i][:m_tokens_len[i] + 1], dim=-1) + + if args.if_maxtest: + _, cls_pred_index = torch.max(probs, dim=-1) + + else: + dist = Categorical(probs) + cls_pred_index = dist.sample() + right_num += (cls_pred_index.flatten(0) == target[i][:m_tokens_len[i] + 1].flatten(0)).sum().item() + + ## global loss + optimizer.zero_grad() + loss_cls.backward() + optimizer.step() + scheduler.step() + + avg_loss_cls = avg_loss_cls + loss_cls.item() + nb_sample_train = nb_sample_train + (m_tokens_len + 1).sum().item() + + nb_iter += 1 + if nb_iter % args.print_iter == 0 : + avg_loss_cls = avg_loss_cls / args.print_iter + avg_acc = right_num * 100 / nb_sample_train + writer.add_scalar('./Loss/train', avg_loss_cls, nb_iter) + writer.add_scalar('./ACC/train', avg_acc, nb_iter) + msg = f"Train. Iter {nb_iter} : Loss. {avg_loss_cls:.5f}, ACC. {avg_acc:.4f}" + logger.info(msg) + avg_loss_cls = 0. + right_num = 0 + nb_sample_train = 0 + + if nb_iter % args.eval_iter == 0: + best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger = eval_trans.evaluation_transformer(args.out_dir, val_loader, net, trans_encoder, logger, writer, nb_iter, best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, clip_model=clip_model, eval_wrapper=eval_wrapper) + + if nb_iter == args.total_iter: + msg_final = f"Train. Iter {best_iter} : FID. {best_fid:.5f}, Diversity. {best_div:.4f}, TOP1. {best_top1:.4f}, TOP2. {best_top2:.4f}, TOP3. {best_top3:.4f}" + logger.info(msg_final) + break \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/train_vq.py b/MuseV/MMCM/mmcm/t2p/train_vq.py new file mode 100755 index 0000000000000000000000000000000000000000..d89b9930ba1262747542df3d5b2f03f8fab1b04a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/train_vq.py @@ -0,0 +1,171 @@ +import os +import json + +import torch +import torch.optim as optim +from torch.utils.tensorboard import SummaryWriter + +import models.vqvae as vqvae +import utils.losses as losses +import options.option_vq as option_vq +import utils.utils_model as utils_model +from dataset import dataset_VQ, dataset_TM_eval +import utils.eval_trans as eval_trans +from options.get_eval_option import get_opt +from models.evaluator_wrapper import EvaluatorModelWrapper +import warnings +warnings.filterwarnings('ignore') +from utils.word_vectorizer import WordVectorizer + +def update_lr_warm_up(optimizer, nb_iter, warm_up_iter, lr): + + current_lr = lr * (nb_iter + 1) / (warm_up_iter + 1) + for param_group in optimizer.param_groups: + param_group["lr"] = current_lr + + return optimizer, current_lr + +##### ---- Exp dirs ---- ##### +args = option_vq.get_args_parser() +torch.manual_seed(args.seed) + +args.out_dir = os.path.join(args.out_dir, f'{args.exp_name}') +os.makedirs(args.out_dir, exist_ok = True) + +##### ---- Logger ---- ##### +logger = utils_model.get_logger(args.out_dir) +writer = SummaryWriter(args.out_dir) +logger.info(json.dumps(vars(args), indent=4, sort_keys=True)) + + + +w_vectorizer = WordVectorizer('./glove', 'our_vab') + +if args.dataname == 'kit' : + dataset_opt_path = 'checkpoints/kit/Comp_v6_KLD005/opt.txt' + args.nb_joints = 21 + +else : + dataset_opt_path = 'checkpoints/t2m/Comp_v6_KLD005/opt.txt' + args.nb_joints = 22 + +logger.info(f'Training on {args.dataname}, motions are with {args.nb_joints} joints') + +wrapper_opt = get_opt(dataset_opt_path, torch.device('cuda')) +eval_wrapper = EvaluatorModelWrapper(wrapper_opt) + + +##### ---- Dataloader ---- ##### +train_loader = dataset_VQ.DATALoader(args.dataname, + args.batch_size, + window_size=args.window_size, + unit_length=2**args.down_t) + +train_loader_iter = dataset_VQ.cycle(train_loader) + +val_loader = dataset_TM_eval.DATALoader(args.dataname, False, + 32, + w_vectorizer, + unit_length=2**args.down_t) + +##### ---- Network ---- ##### +net = vqvae.HumanVQVAE(args, ## use args to define different parameters in different quantizers + args.nb_code, + args.code_dim, + args.output_emb_width, + args.down_t, + args.stride_t, + args.width, + args.depth, + args.dilation_growth_rate, + args.vq_act, + args.vq_norm) + + +if args.resume_pth : + logger.info('loading checkpoint from {}'.format(args.resume_pth)) + ckpt = torch.load(args.resume_pth, map_location='cpu') + net.load_state_dict(ckpt['net'], strict=True) +net.train() +net.cuda() + +##### ---- Optimizer & Scheduler ---- ##### +optimizer = optim.AdamW(net.parameters(), lr=args.lr, betas=(0.9, 0.99), weight_decay=args.weight_decay) +scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_scheduler, gamma=args.gamma) + + +Loss = losses.ReConsLoss(args.recons_loss, args.nb_joints) + +##### ------ warm-up ------- ##### +avg_recons, avg_perplexity, avg_commit = 0., 0., 0. + +for nb_iter in range(1, args.warm_up_iter): + + optimizer, current_lr = update_lr_warm_up(optimizer, nb_iter, args.warm_up_iter, args.lr) + + gt_motion = next(train_loader_iter) + gt_motion = gt_motion.cuda().float() # (bs, 64, dim) + + pred_motion, loss_commit, perplexity = net(gt_motion) + loss_motion = Loss(pred_motion, gt_motion) + loss_vel = Loss.forward_vel(pred_motion, gt_motion) + + loss = loss_motion + args.commit * loss_commit + args.loss_vel * loss_vel + + optimizer.zero_grad() + loss.backward() + optimizer.step() + + avg_recons += loss_motion.item() + avg_perplexity += perplexity.item() + avg_commit += loss_commit.item() + + if nb_iter % args.print_iter == 0 : + avg_recons /= args.print_iter + avg_perplexity /= args.print_iter + avg_commit /= args.print_iter + + logger.info(f"Warmup. Iter {nb_iter} : lr {current_lr:.5f} \t Commit. {avg_commit:.5f} \t PPL. {avg_perplexity:.2f} \t Recons. {avg_recons:.5f}") + + avg_recons, avg_perplexity, avg_commit = 0., 0., 0. + +##### ---- Training ---- ##### +avg_recons, avg_perplexity, avg_commit = 0., 0., 0. +best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger = eval_trans.evaluation_vqvae(args.out_dir, val_loader, net, logger, writer, 0, best_fid=1000, best_iter=0, best_div=100, best_top1=0, best_top2=0, best_top3=0, best_matching=100, eval_wrapper=eval_wrapper) + +for nb_iter in range(1, args.total_iter + 1): + + gt_motion = next(train_loader_iter) + gt_motion = gt_motion.cuda().float() # bs, nb_joints, joints_dim, seq_len + + pred_motion, loss_commit, perplexity = net(gt_motion) + loss_motion = Loss(pred_motion, gt_motion) + loss_vel = Loss.forward_vel(pred_motion, gt_motion) + + loss = loss_motion + args.commit * loss_commit + args.loss_vel * loss_vel + + optimizer.zero_grad() + loss.backward() + optimizer.step() + scheduler.step() + + avg_recons += loss_motion.item() + avg_perplexity += perplexity.item() + avg_commit += loss_commit.item() + + if nb_iter % args.print_iter == 0 : + avg_recons /= args.print_iter + avg_perplexity /= args.print_iter + avg_commit /= args.print_iter + + writer.add_scalar('./Train/L1', avg_recons, nb_iter) + writer.add_scalar('./Train/PPL', avg_perplexity, nb_iter) + writer.add_scalar('./Train/Commit', avg_commit, nb_iter) + + logger.info(f"Train. Iter {nb_iter} : \t Commit. {avg_commit:.5f} \t PPL. {avg_perplexity:.2f} \t Recons. {avg_recons:.5f}") + + avg_recons, avg_perplexity, avg_commit = 0., 0., 0., + + if nb_iter % args.eval_iter==0 : + best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger = eval_trans.evaluation_vqvae(args.out_dir, val_loader, net, logger, writer, nb_iter, best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, eval_wrapper=eval_wrapper) + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/config.py b/MuseV/MMCM/mmcm/t2p/utils/config.py new file mode 100755 index 0000000000000000000000000000000000000000..3489a226c8ef2df8b876052043c9a74ed7222dc2 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/config.py @@ -0,0 +1,17 @@ +import os + +SMPL_DATA_PATH = "/group/30065/users/zhanchao/code/MMCM/mmcm/t2p/body_models/smpl" + +SMPL_KINTREE_PATH = os.path.join(SMPL_DATA_PATH, "kintree_table.pkl") +SMPL_MODEL_PATH = os.path.join(SMPL_DATA_PATH, "SMPL_NEUTRAL.pkl") +JOINT_REGRESSOR_TRAIN_EXTRA = os.path.join(SMPL_DATA_PATH, 'J_regressor_extra.npy') + +ROT_CONVENTION_TO_ROT_NUMBER = { + 'legacy': 23, + 'no_hands': 21, + 'full_hands': 51, + 'mitten_hands': 33, +} + +GENDERS = ['neutral', 'male', 'female'] +NUM_BETAS = 10 \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/eval_trans.py b/MuseV/MMCM/mmcm/t2p/utils/eval_trans.py new file mode 100755 index 0000000000000000000000000000000000000000..6e5fb874b691ca4d2fea50eda20677611997b1e7 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/eval_trans.py @@ -0,0 +1,580 @@ +import os + +import clip +import numpy as np +import torch +from scipy import linalg + +import ..visualization.plot_3d_global as plot_3d +from .motion_process import recover_from_ric + + +def tensorborad_add_video_xyz(writer, xyz, nb_iter, tag, nb_vis=4, title_batch=None, outname=None): + xyz = xyz[:1] + bs, seq = xyz.shape[:2] + xyz = xyz.reshape(bs, seq, -1, 3) + plot_xyz = plot_3d.draw_to_batch(xyz.cpu().numpy(),title_batch, outname) + plot_xyz =np.transpose(plot_xyz, (0, 1, 4, 2, 3)) + writer.add_video(tag, plot_xyz, nb_iter, fps = 20) + +@torch.no_grad() +def evaluation_vqvae(out_dir, val_loader, net, logger, writer, nb_iter, best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, eval_wrapper, draw = True, save = True, savegif=False, savenpy=False) : + net.eval() + nb_sample = 0 + + draw_org = [] + draw_pred = [] + draw_text = [] + + + motion_annotation_list = [] + motion_pred_list = [] + + R_precision_real = 0 + R_precision = 0 + + nb_sample = 0 + matching_score_real = 0 + matching_score_pred = 0 + for batch in val_loader: + word_embeddings, pos_one_hots, caption, sent_len, motion, m_length, token, name = batch + + motion = motion.cuda() + et, em = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, motion, m_length) + bs, seq = motion.shape[0], motion.shape[1] + + num_joints = 21 if motion.shape[-1] == 251 else 22 + + pred_pose_eval = torch.zeros((bs, seq, motion.shape[-1])).cuda() + + for i in range(bs): + pose = val_loader.dataset.inv_transform(motion[i:i+1, :m_length[i], :].detach().cpu().numpy()) + pose_xyz = recover_from_ric(torch.from_numpy(pose).float().cuda(), num_joints) + + + pred_pose, loss_commit, perplexity = net(motion[i:i+1, :m_length[i]]) + pred_denorm = val_loader.dataset.inv_transform(pred_pose.detach().cpu().numpy()) + pred_xyz = recover_from_ric(torch.from_numpy(pred_denorm).float().cuda(), num_joints) + + if savenpy: + np.save(os.path.join(out_dir, name[i]+'_gt.npy'), pose_xyz[:, :m_length[i]].cpu().numpy()) + np.save(os.path.join(out_dir, name[i]+'_pred.npy'), pred_xyz.detach().cpu().numpy()) + + pred_pose_eval[i:i+1,:m_length[i],:] = pred_pose + + if i < min(4, bs): + draw_org.append(pose_xyz) + draw_pred.append(pred_xyz) + draw_text.append(caption[i]) + + et_pred, em_pred = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, pred_pose_eval, m_length) + + motion_pred_list.append(em_pred) + motion_annotation_list.append(em) + + temp_R, temp_match = calculate_R_precision(et.cpu().numpy(), em.cpu().numpy(), top_k=3, sum_all=True) + R_precision_real += temp_R + matching_score_real += temp_match + temp_R, temp_match = calculate_R_precision(et_pred.cpu().numpy(), em_pred.cpu().numpy(), top_k=3, sum_all=True) + R_precision += temp_R + matching_score_pred += temp_match + + nb_sample += bs + + motion_annotation_np = torch.cat(motion_annotation_list, dim=0).cpu().numpy() + motion_pred_np = torch.cat(motion_pred_list, dim=0).cpu().numpy() + gt_mu, gt_cov = calculate_activation_statistics(motion_annotation_np) + mu, cov= calculate_activation_statistics(motion_pred_np) + + diversity_real = calculate_diversity(motion_annotation_np, 300 if nb_sample > 300 else 100) + diversity = calculate_diversity(motion_pred_np, 300 if nb_sample > 300 else 100) + + R_precision_real = R_precision_real / nb_sample + R_precision = R_precision / nb_sample + + matching_score_real = matching_score_real / nb_sample + matching_score_pred = matching_score_pred / nb_sample + + fid = calculate_frechet_distance(gt_mu, gt_cov, mu, cov) + + msg = f"--> \t Eva. Iter {nb_iter} :, FID. {fid:.4f}, Diversity Real. {diversity_real:.4f}, Diversity. {diversity:.4f}, R_precision_real. {R_precision_real}, R_precision. {R_precision}, matching_score_real. {matching_score_real}, matching_score_pred. {matching_score_pred}" + logger.info(msg) + + if draw: + writer.add_scalar('./Test/FID', fid, nb_iter) + writer.add_scalar('./Test/Diversity', diversity, nb_iter) + writer.add_scalar('./Test/top1', R_precision[0], nb_iter) + writer.add_scalar('./Test/top2', R_precision[1], nb_iter) + writer.add_scalar('./Test/top3', R_precision[2], nb_iter) + writer.add_scalar('./Test/matching_score', matching_score_pred, nb_iter) + + + if nb_iter % 5000 == 0 : + for ii in range(4): + tensorborad_add_video_xyz(writer, draw_org[ii], nb_iter, tag='./Vis/org_eval'+str(ii), nb_vis=1, title_batch=[draw_text[ii]], outname=[os.path.join(out_dir, 'gt'+str(ii)+'.gif')] if savegif else None) + + if nb_iter % 5000 == 0 : + for ii in range(4): + tensorborad_add_video_xyz(writer, draw_pred[ii], nb_iter, tag='./Vis/pred_eval'+str(ii), nb_vis=1, title_batch=[draw_text[ii]], outname=[os.path.join(out_dir, 'pred'+str(ii)+'.gif')] if savegif else None) + + + if fid < best_fid : + msg = f"--> --> \t FID Improved from {best_fid:.5f} to {fid:.5f} !!!" + logger.info(msg) + best_fid, best_iter = fid, nb_iter + if save: + torch.save({'net' : net.state_dict()}, os.path.join(out_dir, 'net_best_fid.pth')) + + if abs(diversity_real - diversity) < abs(diversity_real - best_div) : + msg = f"--> --> \t Diversity Improved from {best_div:.5f} to {diversity:.5f} !!!" + logger.info(msg) + best_div = diversity + if save: + torch.save({'net' : net.state_dict()}, os.path.join(out_dir, 'net_best_div.pth')) + + if R_precision[0] > best_top1 : + msg = f"--> --> \t Top1 Improved from {best_top1:.4f} to {R_precision[0]:.4f} !!!" + logger.info(msg) + best_top1 = R_precision[0] + if save: + torch.save({'net' : net.state_dict()}, os.path.join(out_dir, 'net_best_top1.pth')) + + if R_precision[1] > best_top2 : + msg = f"--> --> \t Top2 Improved from {best_top2:.4f} to {R_precision[1]:.4f} !!!" + logger.info(msg) + best_top2 = R_precision[1] + + if R_precision[2] > best_top3 : + msg = f"--> --> \t Top3 Improved from {best_top3:.4f} to {R_precision[2]:.4f} !!!" + logger.info(msg) + best_top3 = R_precision[2] + + if matching_score_pred < best_matching : + msg = f"--> --> \t matching_score Improved from {best_matching:.5f} to {matching_score_pred:.5f} !!!" + logger.info(msg) + best_matching = matching_score_pred + if save: + torch.save({'net' : net.state_dict()}, os.path.join(out_dir, 'net_best_matching.pth')) + + if save: + torch.save({'net' : net.state_dict()}, os.path.join(out_dir, 'net_last.pth')) + + net.train() + return best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger + + +@torch.no_grad() +def evaluation_transformer(out_dir, val_loader, net, trans, logger, writer, nb_iter, best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, clip_model, eval_wrapper, draw = True, save = True, savegif=False) : + + trans.eval() + nb_sample = 0 + + draw_org = [] + draw_pred = [] + draw_text = [] + draw_text_pred = [] + + motion_annotation_list = [] + motion_pred_list = [] + R_precision_real = 0 + R_precision = 0 + matching_score_real = 0 + matching_score_pred = 0 + + nb_sample = 0 + for i in range(1): + for batch in val_loader: + word_embeddings, pos_one_hots, clip_text, sent_len, pose, m_length, token, name = batch + + bs, seq = pose.shape[:2] + num_joints = 21 if pose.shape[-1] == 251 else 22 + + text = clip.tokenize(clip_text, truncate=True).cuda() + + feat_clip_text = clip_model.encode_text(text).float() + pred_pose_eval = torch.zeros((bs, seq, pose.shape[-1])).cuda() + pred_len = torch.ones(bs).long() + + for k in range(bs): + try: + index_motion = trans.sample(feat_clip_text[k:k+1], False) + except: + index_motion = torch.ones(1,1).cuda().long() + + pred_pose = net.forward_decoder(index_motion) + cur_len = pred_pose.shape[1] + + pred_len[k] = min(cur_len, seq) + pred_pose_eval[k:k+1, :cur_len] = pred_pose[:, :seq] + + if draw: + pred_denorm = val_loader.dataset.inv_transform(pred_pose.detach().cpu().numpy()) + pred_xyz = recover_from_ric(torch.from_numpy(pred_denorm).float().cuda(), num_joints) + + if i == 0 and k < 4: + draw_pred.append(pred_xyz) + draw_text_pred.append(clip_text[k]) + + et_pred, em_pred = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, pred_pose_eval, pred_len) + + if i == 0: + pose = pose.cuda().float() + + et, em = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, pose, m_length) + motion_annotation_list.append(em) + motion_pred_list.append(em_pred) + + if draw: + pose = val_loader.dataset.inv_transform(pose.detach().cpu().numpy()) + pose_xyz = recover_from_ric(torch.from_numpy(pose).float().cuda(), num_joints) + + + for j in range(min(4, bs)): + draw_org.append(pose_xyz[j][:m_length[j]].unsqueeze(0)) + draw_text.append(clip_text[j]) + + temp_R, temp_match = calculate_R_precision(et.cpu().numpy(), em.cpu().numpy(), top_k=3, sum_all=True) + R_precision_real += temp_R + matching_score_real += temp_match + temp_R, temp_match = calculate_R_precision(et_pred.cpu().numpy(), em_pred.cpu().numpy(), top_k=3, sum_all=True) + R_precision += temp_R + matching_score_pred += temp_match + + nb_sample += bs + + motion_annotation_np = torch.cat(motion_annotation_list, dim=0).cpu().numpy() + motion_pred_np = torch.cat(motion_pred_list, dim=0).cpu().numpy() + gt_mu, gt_cov = calculate_activation_statistics(motion_annotation_np) + mu, cov= calculate_activation_statistics(motion_pred_np) + + diversity_real = calculate_diversity(motion_annotation_np, 300 if nb_sample > 300 else 100) + diversity = calculate_diversity(motion_pred_np, 300 if nb_sample > 300 else 100) + + R_precision_real = R_precision_real / nb_sample + R_precision = R_precision / nb_sample + + matching_score_real = matching_score_real / nb_sample + matching_score_pred = matching_score_pred / nb_sample + + + fid = calculate_frechet_distance(gt_mu, gt_cov, mu, cov) + + msg = f"--> \t Eva. Iter {nb_iter} :, FID. {fid:.4f}, Diversity Real. {diversity_real:.4f}, Diversity. {diversity:.4f}, R_precision_real. {R_precision_real}, R_precision. {R_precision}, matching_score_real. {matching_score_real}, matching_score_pred. {matching_score_pred}" + logger.info(msg) + + + if draw: + writer.add_scalar('./Test/FID', fid, nb_iter) + writer.add_scalar('./Test/Diversity', diversity, nb_iter) + writer.add_scalar('./Test/top1', R_precision[0], nb_iter) + writer.add_scalar('./Test/top2', R_precision[1], nb_iter) + writer.add_scalar('./Test/top3', R_precision[2], nb_iter) + writer.add_scalar('./Test/matching_score', matching_score_pred, nb_iter) + + + if nb_iter % 10000 == 0 : + for ii in range(4): + tensorborad_add_video_xyz(writer, draw_org[ii], nb_iter, tag='./Vis/org_eval'+str(ii), nb_vis=1, title_batch=[draw_text[ii]], outname=[os.path.join(out_dir, 'gt'+str(ii)+'.gif')] if savegif else None) + + if nb_iter % 10000 == 0 : + for ii in range(4): + tensorborad_add_video_xyz(writer, draw_pred[ii], nb_iter, tag='./Vis/pred_eval'+str(ii), nb_vis=1, title_batch=[draw_text_pred[ii]], outname=[os.path.join(out_dir, 'pred'+str(ii)+'.gif')] if savegif else None) + + + if fid < best_fid : + msg = f"--> --> \t FID Improved from {best_fid:.5f} to {fid:.5f} !!!" + logger.info(msg) + best_fid, best_iter = fid, nb_iter + if save: + torch.save({'trans' : trans.state_dict()}, os.path.join(out_dir, 'net_best_fid.pth')) + + if matching_score_pred < best_matching : + msg = f"--> --> \t matching_score Improved from {best_matching:.5f} to {matching_score_pred:.5f} !!!" + logger.info(msg) + best_matching = matching_score_pred + + if abs(diversity_real - diversity) < abs(diversity_real - best_div) : + msg = f"--> --> \t Diversity Improved from {best_div:.5f} to {diversity:.5f} !!!" + logger.info(msg) + best_div = diversity + + if R_precision[0] > best_top1 : + msg = f"--> --> \t Top1 Improved from {best_top1:.4f} to {R_precision[0]:.4f} !!!" + logger.info(msg) + best_top1 = R_precision[0] + + if R_precision[1] > best_top2 : + msg = f"--> --> \t Top2 Improved from {best_top2:.4f} to {R_precision[1]:.4f} !!!" + logger.info(msg) + best_top2 = R_precision[1] + + if R_precision[2] > best_top3 : + msg = f"--> --> \t Top3 Improved from {best_top3:.4f} to {R_precision[2]:.4f} !!!" + logger.info(msg) + best_top3 = R_precision[2] + + if save: + torch.save({'trans' : trans.state_dict()}, os.path.join(out_dir, 'net_last.pth')) + + trans.train() + return best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, writer, logger + + +@torch.no_grad() +def evaluation_transformer_test(out_dir, val_loader, net, trans, logger, writer, nb_iter, best_fid, best_iter, best_div, best_top1, best_top2, best_top3, best_matching, best_multi, clip_model, eval_wrapper, draw = True, save = True, savegif=False, savenpy=False) : + + trans.eval() + nb_sample = 0 + + draw_org = [] + draw_pred = [] + draw_text = [] + draw_text_pred = [] + draw_name = [] + + motion_annotation_list = [] + motion_pred_list = [] + motion_multimodality = [] + R_precision_real = 0 + R_precision = 0 + matching_score_real = 0 + matching_score_pred = 0 + + nb_sample = 0 + + for batch in val_loader: + + word_embeddings, pos_one_hots, clip_text, sent_len, pose, m_length, token, name = batch + bs, seq = pose.shape[:2] + num_joints = 21 if pose.shape[-1] == 251 else 22 + + text = clip.tokenize(clip_text, truncate=True).cuda() + + feat_clip_text = clip_model.encode_text(text).float() + motion_multimodality_batch = [] + for i in range(30): + pred_pose_eval = torch.zeros((bs, seq, pose.shape[-1])).cuda() + pred_len = torch.ones(bs).long() + + for k in range(bs): + try: + index_motion = trans.sample(feat_clip_text[k:k+1], True) + except: + index_motion = torch.ones(1,1).cuda().long() + + pred_pose = net.forward_decoder(index_motion) + cur_len = pred_pose.shape[1] + + pred_len[k] = min(cur_len, seq) + pred_pose_eval[k:k+1, :cur_len] = pred_pose[:, :seq] + + if i == 0 and (draw or savenpy): + pred_denorm = val_loader.dataset.inv_transform(pred_pose.detach().cpu().numpy()) + pred_xyz = recover_from_ric(torch.from_numpy(pred_denorm).float().cuda(), num_joints) + + if savenpy: + np.save(os.path.join(out_dir, name[k]+'_pred.npy'), pred_xyz.detach().cpu().numpy()) + + if draw: + if i == 0: + draw_pred.append(pred_xyz) + draw_text_pred.append(clip_text[k]) + draw_name.append(name[k]) + + et_pred, em_pred = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, pred_pose_eval, pred_len) + + motion_multimodality_batch.append(em_pred.reshape(bs, 1, -1)) + + if i == 0: + pose = pose.cuda().float() + + et, em = eval_wrapper.get_co_embeddings(word_embeddings, pos_one_hots, sent_len, pose, m_length) + motion_annotation_list.append(em) + motion_pred_list.append(em_pred) + + if draw or savenpy: + pose = val_loader.dataset.inv_transform(pose.detach().cpu().numpy()) + pose_xyz = recover_from_ric(torch.from_numpy(pose).float().cuda(), num_joints) + + if savenpy: + for j in range(bs): + np.save(os.path.join(out_dir, name[j]+'_gt.npy'), pose_xyz[j][:m_length[j]].unsqueeze(0).cpu().numpy()) + + if draw: + for j in range(bs): + draw_org.append(pose_xyz[j][:m_length[j]].unsqueeze(0)) + draw_text.append(clip_text[j]) + + temp_R, temp_match = calculate_R_precision(et.cpu().numpy(), em.cpu().numpy(), top_k=3, sum_all=True) + R_precision_real += temp_R + matching_score_real += temp_match + temp_R, temp_match = calculate_R_precision(et_pred.cpu().numpy(), em_pred.cpu().numpy(), top_k=3, sum_all=True) + R_precision += temp_R + matching_score_pred += temp_match + + nb_sample += bs + + motion_multimodality.append(torch.cat(motion_multimodality_batch, dim=1)) + + motion_annotation_np = torch.cat(motion_annotation_list, dim=0).cpu().numpy() + motion_pred_np = torch.cat(motion_pred_list, dim=0).cpu().numpy() + gt_mu, gt_cov = calculate_activation_statistics(motion_annotation_np) + mu, cov= calculate_activation_statistics(motion_pred_np) + + diversity_real = calculate_diversity(motion_annotation_np, 300 if nb_sample > 300 else 100) + diversity = calculate_diversity(motion_pred_np, 300 if nb_sample > 300 else 100) + + R_precision_real = R_precision_real / nb_sample + R_precision = R_precision / nb_sample + + matching_score_real = matching_score_real / nb_sample + matching_score_pred = matching_score_pred / nb_sample + + multimodality = 0 + motion_multimodality = torch.cat(motion_multimodality, dim=0).cpu().numpy() + multimodality = calculate_multimodality(motion_multimodality, 10) + + fid = calculate_frechet_distance(gt_mu, gt_cov, mu, cov) + + msg = f"--> \t Eva. Iter {nb_iter} :, FID. {fid:.4f}, Diversity Real. {diversity_real:.4f}, Diversity. {diversity:.4f}, R_precision_real. {R_precision_real}, R_precision. {R_precision}, matching_score_real. {matching_score_real}, matching_score_pred. {matching_score_pred}, multimodality. {multimodality:.4f}" + logger.info(msg) + + + if draw: + for ii in range(len(draw_org)): + tensorborad_add_video_xyz(writer, draw_org[ii], nb_iter, tag='./Vis/'+draw_name[ii]+'_org', nb_vis=1, title_batch=[draw_text[ii]], outname=[os.path.join(out_dir, draw_name[ii]+'_skel_gt.gif')] if savegif else None) + + tensorborad_add_video_xyz(writer, draw_pred[ii], nb_iter, tag='./Vis/'+draw_name[ii]+'_pred', nb_vis=1, title_batch=[draw_text_pred[ii]], outname=[os.path.join(out_dir, draw_name[ii]+'_skel_pred.gif')] if savegif else None) + + trans.train() + return fid, best_iter, diversity, R_precision[0], R_precision[1], R_precision[2], matching_score_pred, multimodality, writer, logger + +# (X - X_train)*(X - X_train) = -2X*X_train + X*X + X_train*X_train +def euclidean_distance_matrix(matrix1, matrix2): + """ + Params: + -- matrix1: N1 x D + -- matrix2: N2 x D + Returns: + -- dist: N1 x N2 + dist[i, j] == distance(matrix1[i], matrix2[j]) + """ + assert matrix1.shape[1] == matrix2.shape[1] + d1 = -2 * np.dot(matrix1, matrix2.T) # shape (num_test, num_train) + d2 = np.sum(np.square(matrix1), axis=1, keepdims=True) # shape (num_test, 1) + d3 = np.sum(np.square(matrix2), axis=1) # shape (num_train, ) + dists = np.sqrt(d1 + d2 + d3) # broadcasting + return dists + + + +def calculate_top_k(mat, top_k): + size = mat.shape[0] + gt_mat = np.expand_dims(np.arange(size), 1).repeat(size, 1) + bool_mat = (mat == gt_mat) + correct_vec = False + top_k_list = [] + for i in range(top_k): +# print(correct_vec, bool_mat[:, i]) + correct_vec = (correct_vec | bool_mat[:, i]) + # print(correct_vec) + top_k_list.append(correct_vec[:, None]) + top_k_mat = np.concatenate(top_k_list, axis=1) + return top_k_mat + + +def calculate_R_precision(embedding1, embedding2, top_k, sum_all=False): + dist_mat = euclidean_distance_matrix(embedding1, embedding2) + matching_score = dist_mat.trace() + argmax = np.argsort(dist_mat, axis=1) + top_k_mat = calculate_top_k(argmax, top_k) + if sum_all: + return top_k_mat.sum(axis=0), matching_score + else: + return top_k_mat, matching_score + +def calculate_multimodality(activation, multimodality_times): + assert len(activation.shape) == 3 + assert activation.shape[1] > multimodality_times + num_per_sent = activation.shape[1] + + first_dices = np.random.choice(num_per_sent, multimodality_times, replace=False) + second_dices = np.random.choice(num_per_sent, multimodality_times, replace=False) + dist = linalg.norm(activation[:, first_dices] - activation[:, second_dices], axis=2) + return dist.mean() + + +def calculate_diversity(activation, diversity_times): + assert len(activation.shape) == 2 + assert activation.shape[0] > diversity_times + num_samples = activation.shape[0] + + first_indices = np.random.choice(num_samples, diversity_times, replace=False) + second_indices = np.random.choice(num_samples, diversity_times, replace=False) + dist = linalg.norm(activation[first_indices] - activation[second_indices], axis=1) + return dist.mean() + + + +def calculate_frechet_distance(mu1, sigma1, mu2, sigma2, eps=1e-6): + + mu1 = np.atleast_1d(mu1) + mu2 = np.atleast_1d(mu2) + + sigma1 = np.atleast_2d(sigma1) + sigma2 = np.atleast_2d(sigma2) + + assert mu1.shape == mu2.shape, \ + 'Training and test mean vectors have different lengths' + assert sigma1.shape == sigma2.shape, \ + 'Training and test covariances have different dimensions' + + diff = mu1 - mu2 + + # Product might be almost singular + covmean, _ = linalg.sqrtm(sigma1.dot(sigma2), disp=False) + if not np.isfinite(covmean).all(): + msg = ('fid calculation produces singular product; ' + 'adding %s to diagonal of cov estimates') % eps + print(msg) + offset = np.eye(sigma1.shape[0]) * eps + covmean = linalg.sqrtm((sigma1 + offset).dot(sigma2 + offset)) + + # Numerical error might give slight imaginary component + if np.iscomplexobj(covmean): + if not np.allclose(np.diagonal(covmean).imag, 0, atol=1e-3): + m = np.max(np.abs(covmean.imag)) + raise ValueError('Imaginary component {}'.format(m)) + covmean = covmean.real + + tr_covmean = np.trace(covmean) + + return (diff.dot(diff) + np.trace(sigma1) + + np.trace(sigma2) - 2 * tr_covmean) + + + +def calculate_activation_statistics(activations): + + mu = np.mean(activations, axis=0) + cov = np.cov(activations, rowvar=False) + return mu, cov + + +def calculate_frechet_feature_distance(feature_list1, feature_list2): + feature_list1 = np.stack(feature_list1) + feature_list2 = np.stack(feature_list2) + + # normalize the scale + mean = np.mean(feature_list1, axis=0) + std = np.std(feature_list1, axis=0) + 1e-10 + feature_list1 = (feature_list1 - mean) / std + feature_list2 = (feature_list2 - mean) / std + + dist = calculate_frechet_distance( + mu1=np.mean(feature_list1, axis=0), + sigma1=np.cov(feature_list1, rowvar=False), + mu2=np.mean(feature_list2, axis=0), + sigma2=np.cov(feature_list2, rowvar=False), + ) + return dist \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/losses.py b/MuseV/MMCM/mmcm/t2p/utils/losses.py new file mode 100755 index 0000000000000000000000000000000000000000..1998161032731fc2c3edae701700679c00fd00d0 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/losses.py @@ -0,0 +1,30 @@ +import torch +import torch.nn as nn + +class ReConsLoss(nn.Module): + def __init__(self, recons_loss, nb_joints): + super(ReConsLoss, self).__init__() + + if recons_loss == 'l1': + self.Loss = torch.nn.L1Loss() + elif recons_loss == 'l2' : + self.Loss = torch.nn.MSELoss() + elif recons_loss == 'l1_smooth' : + self.Loss = torch.nn.SmoothL1Loss() + + # 4 global motion associated to root + # 12 local motion (3 local xyz, 3 vel xyz, 6 rot6d) + # 3 global vel xyz + # 4 foot contact + self.nb_joints = nb_joints + self.motion_dim = (nb_joints - 1) * 12 + 4 + 3 + 4 + + def forward(self, motion_pred, motion_gt) : + loss = self.Loss(motion_pred[..., : self.motion_dim], motion_gt[..., :self.motion_dim]) + return loss + + def forward_vel(self, motion_pred, motion_gt) : + loss = self.Loss(motion_pred[..., 4 : (self.nb_joints - 1) * 3 + 4], motion_gt[..., 4 : (self.nb_joints - 1) * 3 + 4]) + return loss + + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/motion_process.py b/MuseV/MMCM/mmcm/t2p/utils/motion_process.py new file mode 100755 index 0000000000000000000000000000000000000000..d8e203292dd3c629bf14fd48f94c9f10d8b4eeda --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/motion_process.py @@ -0,0 +1,59 @@ +import torch +from .quaternion import quaternion_to_cont6d, qrot, qinv + +def recover_root_rot_pos(data): + rot_vel = data[..., 0] + r_rot_ang = torch.zeros_like(rot_vel).to(data.device) + '''Get Y-axis rotation from rotation velocity''' + r_rot_ang[..., 1:] = rot_vel[..., :-1] + r_rot_ang = torch.cumsum(r_rot_ang, dim=-1) + + r_rot_quat = torch.zeros(data.shape[:-1] + (4,)).to(data.device) + r_rot_quat[..., 0] = torch.cos(r_rot_ang) + r_rot_quat[..., 2] = torch.sin(r_rot_ang) + + r_pos = torch.zeros(data.shape[:-1] + (3,)).to(data.device) + r_pos[..., 1:, [0, 2]] = data[..., :-1, 1:3] + '''Add Y-axis rotation to root position''' + r_pos = qrot(qinv(r_rot_quat), r_pos) + + r_pos = torch.cumsum(r_pos, dim=-2) + + r_pos[..., 1] = data[..., 3] + return r_rot_quat, r_pos + + +def recover_from_rot(data, joints_num, skeleton): + r_rot_quat, r_pos = recover_root_rot_pos(data) + + r_rot_cont6d = quaternion_to_cont6d(r_rot_quat) + + start_indx = 1 + 2 + 1 + (joints_num - 1) * 3 + end_indx = start_indx + (joints_num - 1) * 6 + cont6d_params = data[..., start_indx:end_indx] + # print(r_rot_cont6d.shape, cont6d_params.shape, r_pos.shape) + cont6d_params = torch.cat([r_rot_cont6d, cont6d_params], dim=-1) + cont6d_params = cont6d_params.view(-1, joints_num, 6) + + positions = skeleton.forward_kinematics_cont6d(cont6d_params, r_pos) + + return positions + + +def recover_from_ric(data, joints_num): + r_rot_quat, r_pos = recover_root_rot_pos(data) + positions = data[..., 4:(joints_num - 1) * 3 + 4] + positions = positions.view(positions.shape[:-1] + (-1, 3)) + + '''Add Y-axis rotation to local joints''' + positions = qrot(qinv(r_rot_quat[..., None, :]).expand(positions.shape[:-1] + (4,)), positions) + + '''Add root XZ to joints''' + positions[..., 0] += r_pos[..., 0:1] + positions[..., 2] += r_pos[..., 2:3] + + '''Concate root and joints''' + positions = torch.cat([r_pos.unsqueeze(-2), positions], dim=-2) + + return positions + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/paramUtil.py b/MuseV/MMCM/mmcm/t2p/utils/paramUtil.py new file mode 100755 index 0000000000000000000000000000000000000000..a9f1708b85ca80a9051cb3675cec9b999a0d0e2b --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/paramUtil.py @@ -0,0 +1,63 @@ +import numpy as np + +# Define a kinematic tree for the skeletal struture +kit_kinematic_chain = [[0, 11, 12, 13, 14, 15], [0, 16, 17, 18, 19, 20], [0, 1, 2, 3, 4], [3, 5, 6, 7], [3, 8, 9, 10]] + +kit_raw_offsets = np.array( + [ + [0, 0, 0], + [0, 1, 0], + [0, 1, 0], + [0, 1, 0], + [0, 1, 0], + [1, 0, 0], + [0, -1, 0], + [0, -1, 0], + [-1, 0, 0], + [0, -1, 0], + [0, -1, 0], + [1, 0, 0], + [0, -1, 0], + [0, -1, 0], + [0, 0, 1], + [0, 0, 1], + [-1, 0, 0], + [0, -1, 0], + [0, -1, 0], + [0, 0, 1], + [0, 0, 1] + ] +) + +t2m_raw_offsets = np.array([[0,0,0], + [1,0,0], + [-1,0,0], + [0,1,0], + [0,-1,0], + [0,-1,0], + [0,1,0], + [0,-1,0], + [0,-1,0], + [0,1,0], + [0,0,1], + [0,0,1], + [0,1,0], + [1,0,0], + [-1,0,0], + [0,0,1], + [0,-1,0], + [0,-1,0], + [0,-1,0], + [0,-1,0], + [0,-1,0], + [0,-1,0]]) + +t2m_kinematic_chain = [[0, 2, 5, 8, 11], [0, 1, 4, 7, 10], [0, 3, 6, 9, 12, 15], [9, 14, 17, 19, 21], [9, 13, 16, 18, 20]] +t2m_left_hand_chain = [[20, 22, 23, 24], [20, 34, 35, 36], [20, 25, 26, 27], [20, 31, 32, 33], [20, 28, 29, 30]] +t2m_right_hand_chain = [[21, 43, 44, 45], [21, 46, 47, 48], [21, 40, 41, 42], [21, 37, 38, 39], [21, 49, 50, 51]] + + +kit_tgt_skel_id = '03950' + +t2m_tgt_skel_id = '000021' + diff --git a/MuseV/MMCM/mmcm/t2p/utils/quaternion.py b/MuseV/MMCM/mmcm/t2p/utils/quaternion.py new file mode 100755 index 0000000000000000000000000000000000000000..e2daa00aef1df60e43775864d1dd3d551f89ded8 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/quaternion.py @@ -0,0 +1,423 @@ +# Copyright (c) 2018-present, Facebook, Inc. +# All rights reserved. +# +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. +# + +import torch +import numpy as np + +_EPS4 = np.finfo(float).eps * 4.0 + +_FLOAT_EPS = np.finfo(np.float).eps + +# PyTorch-backed implementations +def qinv(q): + assert q.shape[-1] == 4, 'q must be a tensor of shape (*, 4)' + mask = torch.ones_like(q) + mask[..., 1:] = -mask[..., 1:] + return q * mask + + +def qinv_np(q): + assert q.shape[-1] == 4, 'q must be a tensor of shape (*, 4)' + return qinv(torch.from_numpy(q).float()).numpy() + + +def qnormalize(q): + assert q.shape[-1] == 4, 'q must be a tensor of shape (*, 4)' + return q / torch.norm(q, dim=-1, keepdim=True) + + +def qmul(q, r): + """ + Multiply quaternion(s) q with quaternion(s) r. + Expects two equally-sized tensors of shape (*, 4), where * denotes any number of dimensions. + Returns q*r as a tensor of shape (*, 4). + """ + assert q.shape[-1] == 4 + assert r.shape[-1] == 4 + + original_shape = q.shape + + # Compute outer product + terms = torch.bmm(r.view(-1, 4, 1), q.view(-1, 1, 4)) + + w = terms[:, 0, 0] - terms[:, 1, 1] - terms[:, 2, 2] - terms[:, 3, 3] + x = terms[:, 0, 1] + terms[:, 1, 0] - terms[:, 2, 3] + terms[:, 3, 2] + y = terms[:, 0, 2] + terms[:, 1, 3] + terms[:, 2, 0] - terms[:, 3, 1] + z = terms[:, 0, 3] - terms[:, 1, 2] + terms[:, 2, 1] + terms[:, 3, 0] + return torch.stack((w, x, y, z), dim=1).view(original_shape) + + +def qrot(q, v): + """ + Rotate vector(s) v about the rotation described by quaternion(s) q. + Expects a tensor of shape (*, 4) for q and a tensor of shape (*, 3) for v, + where * denotes any number of dimensions. + Returns a tensor of shape (*, 3). + """ + assert q.shape[-1] == 4 + assert v.shape[-1] == 3 + assert q.shape[:-1] == v.shape[:-1] + + original_shape = list(v.shape) + # print(q.shape) + q = q.contiguous().view(-1, 4) + v = v.contiguous().view(-1, 3) + + qvec = q[:, 1:] + uv = torch.cross(qvec, v, dim=1) + uuv = torch.cross(qvec, uv, dim=1) + return (v + 2 * (q[:, :1] * uv + uuv)).view(original_shape) + + +def qeuler(q, order, epsilon=0, deg=True): + """ + Convert quaternion(s) q to Euler angles. + Expects a tensor of shape (*, 4), where * denotes any number of dimensions. + Returns a tensor of shape (*, 3). + """ + assert q.shape[-1] == 4 + + original_shape = list(q.shape) + original_shape[-1] = 3 + q = q.view(-1, 4) + + q0 = q[:, 0] + q1 = q[:, 1] + q2 = q[:, 2] + q3 = q[:, 3] + + if order == 'xyz': + x = torch.atan2(2 * (q0 * q1 - q2 * q3), 1 - 2 * (q1 * q1 + q2 * q2)) + y = torch.asin(torch.clamp(2 * (q1 * q3 + q0 * q2), -1 + epsilon, 1 - epsilon)) + z = torch.atan2(2 * (q0 * q3 - q1 * q2), 1 - 2 * (q2 * q2 + q3 * q3)) + elif order == 'yzx': + x = torch.atan2(2 * (q0 * q1 - q2 * q3), 1 - 2 * (q1 * q1 + q3 * q3)) + y = torch.atan2(2 * (q0 * q2 - q1 * q3), 1 - 2 * (q2 * q2 + q3 * q3)) + z = torch.asin(torch.clamp(2 * (q1 * q2 + q0 * q3), -1 + epsilon, 1 - epsilon)) + elif order == 'zxy': + x = torch.asin(torch.clamp(2 * (q0 * q1 + q2 * q3), -1 + epsilon, 1 - epsilon)) + y = torch.atan2(2 * (q0 * q2 - q1 * q3), 1 - 2 * (q1 * q1 + q2 * q2)) + z = torch.atan2(2 * (q0 * q3 - q1 * q2), 1 - 2 * (q1 * q1 + q3 * q3)) + elif order == 'xzy': + x = torch.atan2(2 * (q0 * q1 + q2 * q3), 1 - 2 * (q1 * q1 + q3 * q3)) + y = torch.atan2(2 * (q0 * q2 + q1 * q3), 1 - 2 * (q2 * q2 + q3 * q3)) + z = torch.asin(torch.clamp(2 * (q0 * q3 - q1 * q2), -1 + epsilon, 1 - epsilon)) + elif order == 'yxz': + x = torch.asin(torch.clamp(2 * (q0 * q1 - q2 * q3), -1 + epsilon, 1 - epsilon)) + y = torch.atan2(2 * (q1 * q3 + q0 * q2), 1 - 2 * (q1 * q1 + q2 * q2)) + z = torch.atan2(2 * (q1 * q2 + q0 * q3), 1 - 2 * (q1 * q1 + q3 * q3)) + elif order == 'zyx': + x = torch.atan2(2 * (q0 * q1 + q2 * q3), 1 - 2 * (q1 * q1 + q2 * q2)) + y = torch.asin(torch.clamp(2 * (q0 * q2 - q1 * q3), -1 + epsilon, 1 - epsilon)) + z = torch.atan2(2 * (q0 * q3 + q1 * q2), 1 - 2 * (q2 * q2 + q3 * q3)) + else: + raise + + if deg: + return torch.stack((x, y, z), dim=1).view(original_shape) * 180 / np.pi + else: + return torch.stack((x, y, z), dim=1).view(original_shape) + + +# Numpy-backed implementations + +def qmul_np(q, r): + q = torch.from_numpy(q).contiguous().float() + r = torch.from_numpy(r).contiguous().float() + return qmul(q, r).numpy() + + +def qrot_np(q, v): + q = torch.from_numpy(q).contiguous().float() + v = torch.from_numpy(v).contiguous().float() + return qrot(q, v).numpy() + + +def qeuler_np(q, order, epsilon=0, use_gpu=False): + if use_gpu: + q = torch.from_numpy(q).cuda().float() + return qeuler(q, order, epsilon).cpu().numpy() + else: + q = torch.from_numpy(q).contiguous().float() + return qeuler(q, order, epsilon).numpy() + + +def qfix(q): + """ + Enforce quaternion continuity across the time dimension by selecting + the representation (q or -q) with minimal distance (or, equivalently, maximal dot product) + between two consecutive frames. + + Expects a tensor of shape (L, J, 4), where L is the sequence length and J is the number of joints. + Returns a tensor of the same shape. + """ + assert len(q.shape) == 3 + assert q.shape[-1] == 4 + + result = q.copy() + dot_products = np.sum(q[1:] * q[:-1], axis=2) + mask = dot_products < 0 + mask = (np.cumsum(mask, axis=0) % 2).astype(bool) + result[1:][mask] *= -1 + return result + + +def euler2quat(e, order, deg=True): + """ + Convert Euler angles to quaternions. + """ + assert e.shape[-1] == 3 + + original_shape = list(e.shape) + original_shape[-1] = 4 + + e = e.view(-1, 3) + + ## if euler angles in degrees + if deg: + e = e * np.pi / 180. + + x = e[:, 0] + y = e[:, 1] + z = e[:, 2] + + rx = torch.stack((torch.cos(x / 2), torch.sin(x / 2), torch.zeros_like(x), torch.zeros_like(x)), dim=1) + ry = torch.stack((torch.cos(y / 2), torch.zeros_like(y), torch.sin(y / 2), torch.zeros_like(y)), dim=1) + rz = torch.stack((torch.cos(z / 2), torch.zeros_like(z), torch.zeros_like(z), torch.sin(z / 2)), dim=1) + + result = None + for coord in order: + if coord == 'x': + r = rx + elif coord == 'y': + r = ry + elif coord == 'z': + r = rz + else: + raise + if result is None: + result = r + else: + result = qmul(result, r) + + # Reverse antipodal representation to have a non-negative "w" + if order in ['xyz', 'yzx', 'zxy']: + result *= -1 + + return result.view(original_shape) + + +def expmap_to_quaternion(e): + """ + Convert axis-angle rotations (aka exponential maps) to quaternions. + Stable formula from "Practical Parameterization of Rotations Using the Exponential Map". + Expects a tensor of shape (*, 3), where * denotes any number of dimensions. + Returns a tensor of shape (*, 4). + """ + assert e.shape[-1] == 3 + + original_shape = list(e.shape) + original_shape[-1] = 4 + e = e.reshape(-1, 3) + + theta = np.linalg.norm(e, axis=1).reshape(-1, 1) + w = np.cos(0.5 * theta).reshape(-1, 1) + xyz = 0.5 * np.sinc(0.5 * theta / np.pi) * e + return np.concatenate((w, xyz), axis=1).reshape(original_shape) + + +def euler_to_quaternion(e, order): + """ + Convert Euler angles to quaternions. + """ + assert e.shape[-1] == 3 + + original_shape = list(e.shape) + original_shape[-1] = 4 + + e = e.reshape(-1, 3) + + x = e[:, 0] + y = e[:, 1] + z = e[:, 2] + + rx = np.stack((np.cos(x / 2), np.sin(x / 2), np.zeros_like(x), np.zeros_like(x)), axis=1) + ry = np.stack((np.cos(y / 2), np.zeros_like(y), np.sin(y / 2), np.zeros_like(y)), axis=1) + rz = np.stack((np.cos(z / 2), np.zeros_like(z), np.zeros_like(z), np.sin(z / 2)), axis=1) + + result = None + for coord in order: + if coord == 'x': + r = rx + elif coord == 'y': + r = ry + elif coord == 'z': + r = rz + else: + raise + if result is None: + result = r + else: + result = qmul_np(result, r) + + # Reverse antipodal representation to have a non-negative "w" + if order in ['xyz', 'yzx', 'zxy']: + result *= -1 + + return result.reshape(original_shape) + + +def quaternion_to_matrix(quaternions): + """ + Convert rotations given as quaternions to rotation matrices. + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + r, i, j, k = torch.unbind(quaternions, -1) + two_s = 2.0 / (quaternions * quaternions).sum(-1) + + o = torch.stack( + ( + 1 - two_s * (j * j + k * k), + two_s * (i * j - k * r), + two_s * (i * k + j * r), + two_s * (i * j + k * r), + 1 - two_s * (i * i + k * k), + two_s * (j * k - i * r), + two_s * (i * k - j * r), + two_s * (j * k + i * r), + 1 - two_s * (i * i + j * j), + ), + -1, + ) + return o.reshape(quaternions.shape[:-1] + (3, 3)) + + +def quaternion_to_matrix_np(quaternions): + q = torch.from_numpy(quaternions).contiguous().float() + return quaternion_to_matrix(q).numpy() + + +def quaternion_to_cont6d_np(quaternions): + rotation_mat = quaternion_to_matrix_np(quaternions) + cont_6d = np.concatenate([rotation_mat[..., 0], rotation_mat[..., 1]], axis=-1) + return cont_6d + + +def quaternion_to_cont6d(quaternions): + rotation_mat = quaternion_to_matrix(quaternions) + cont_6d = torch.cat([rotation_mat[..., 0], rotation_mat[..., 1]], dim=-1) + return cont_6d + + +def cont6d_to_matrix(cont6d): + assert cont6d.shape[-1] == 6, "The last dimension must be 6" + x_raw = cont6d[..., 0:3] + y_raw = cont6d[..., 3:6] + + x = x_raw / torch.norm(x_raw, dim=-1, keepdim=True) + z = torch.cross(x, y_raw, dim=-1) + z = z / torch.norm(z, dim=-1, keepdim=True) + + y = torch.cross(z, x, dim=-1) + + x = x[..., None] + y = y[..., None] + z = z[..., None] + + mat = torch.cat([x, y, z], dim=-1) + return mat + + +def cont6d_to_matrix_np(cont6d): + q = torch.from_numpy(cont6d).contiguous().float() + return cont6d_to_matrix(q).numpy() + + +def qpow(q0, t, dtype=torch.float): + ''' q0 : tensor of quaternions + t: tensor of powers + ''' + q0 = qnormalize(q0) + theta0 = torch.acos(q0[..., 0]) + + ## if theta0 is close to zero, add epsilon to avoid NaNs + mask = (theta0 <= 10e-10) * (theta0 >= -10e-10) + theta0 = (1 - mask) * theta0 + mask * 10e-10 + v0 = q0[..., 1:] / torch.sin(theta0).view(-1, 1) + + if isinstance(t, torch.Tensor): + q = torch.zeros(t.shape + q0.shape) + theta = t.view(-1, 1) * theta0.view(1, -1) + else: ## if t is a number + q = torch.zeros(q0.shape) + theta = t * theta0 + + q[..., 0] = torch.cos(theta) + q[..., 1:] = v0 * torch.sin(theta).unsqueeze(-1) + + return q.to(dtype) + + +def qslerp(q0, q1, t): + ''' + q0: starting quaternion + q1: ending quaternion + t: array of points along the way + + Returns: + Tensor of Slerps: t.shape + q0.shape + ''' + + q0 = qnormalize(q0) + q1 = qnormalize(q1) + q_ = qpow(qmul(q1, qinv(q0)), t) + + return qmul(q_, + q0.contiguous().view(torch.Size([1] * len(t.shape)) + q0.shape).expand(t.shape + q0.shape).contiguous()) + + +def qbetween(v0, v1): + ''' + find the quaternion used to rotate v0 to v1 + ''' + assert v0.shape[-1] == 3, 'v0 must be of the shape (*, 3)' + assert v1.shape[-1] == 3, 'v1 must be of the shape (*, 3)' + + v = torch.cross(v0, v1) + w = torch.sqrt((v0 ** 2).sum(dim=-1, keepdim=True) * (v1 ** 2).sum(dim=-1, keepdim=True)) + (v0 * v1).sum(dim=-1, + keepdim=True) + return qnormalize(torch.cat([w, v], dim=-1)) + + +def qbetween_np(v0, v1): + ''' + find the quaternion used to rotate v0 to v1 + ''' + assert v0.shape[-1] == 3, 'v0 must be of the shape (*, 3)' + assert v1.shape[-1] == 3, 'v1 must be of the shape (*, 3)' + + v0 = torch.from_numpy(v0).float() + v1 = torch.from_numpy(v1).float() + return qbetween(v0, v1).numpy() + + +def lerp(p0, p1, t): + if not isinstance(t, torch.Tensor): + t = torch.Tensor([t]) + + new_shape = t.shape + p0.shape + new_view_t = t.shape + torch.Size([1] * len(p0.shape)) + new_view_p = torch.Size([1] * len(t.shape)) + p0.shape + p0 = p0.view(new_view_p).expand(new_shape) + p1 = p1.view(new_view_p).expand(new_shape) + t = t.view(new_view_t).expand(new_shape) + + return p0 + t * (p1 - p0) diff --git a/MuseV/MMCM/mmcm/t2p/utils/rotation_conversions.py b/MuseV/MMCM/mmcm/t2p/utils/rotation_conversions.py new file mode 100755 index 0000000000000000000000000000000000000000..1006e8a3117b231a7a456d5b826e76347fe0bfd4 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/rotation_conversions.py @@ -0,0 +1,532 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +# Check PYTORCH3D_LICENCE before use + +import functools +from typing import Optional + +import torch +import torch.nn.functional as F + + +""" +The transformation matrices returned from the functions in this file assume +the points on which the transformation will be applied are column vectors. +i.e. the R matrix is structured as + R = [ + [Rxx, Rxy, Rxz], + [Ryx, Ryy, Ryz], + [Rzx, Rzy, Rzz], + ] # (3, 3) +This matrix can be applied to column vectors by post multiplication +by the points e.g. + points = [[0], [1], [2]] # (3 x 1) xyz coordinates of a point + transformed_points = R * points +To apply the same matrix to points which are row vectors, the R matrix +can be transposed and pre multiplied by the points: +e.g. + points = [[0, 1, 2]] # (1 x 3) xyz coordinates of a point + transformed_points = points * R.transpose(1, 0) +""" + + +def quaternion_to_matrix(quaternions): + """ + Convert rotations given as quaternions to rotation matrices. + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + r, i, j, k = torch.unbind(quaternions, -1) + two_s = 2.0 / (quaternions * quaternions).sum(-1) + + o = torch.stack( + ( + 1 - two_s * (j * j + k * k), + two_s * (i * j - k * r), + two_s * (i * k + j * r), + two_s * (i * j + k * r), + 1 - two_s * (i * i + k * k), + two_s * (j * k - i * r), + two_s * (i * k - j * r), + two_s * (j * k + i * r), + 1 - two_s * (i * i + j * j), + ), + -1, + ) + return o.reshape(quaternions.shape[:-1] + (3, 3)) + + +def _copysign(a, b): + """ + Return a tensor where each element has the absolute value taken from the, + corresponding element of a, with sign taken from the corresponding + element of b. This is like the standard copysign floating-point operation, + but is not careful about negative 0 and NaN. + Args: + a: source tensor. + b: tensor whose signs will be used, of the same shape as a. + Returns: + Tensor of the same shape as a with the signs of b. + """ + signs_differ = (a < 0) != (b < 0) + return torch.where(signs_differ, -a, a) + + +def _sqrt_positive_part(x): + """ + Returns torch.sqrt(torch.max(0, x)) + but with a zero subgradient where x is 0. + """ + ret = torch.zeros_like(x) + positive_mask = x > 0 + ret[positive_mask] = torch.sqrt(x[positive_mask]) + return ret + + +def matrix_to_quaternion(matrix): + """ + Convert rotations given as rotation matrices to quaternions. + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + Returns: + quaternions with real part first, as tensor of shape (..., 4). + """ + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape f{matrix.shape}.") + m00 = matrix[..., 0, 0] + m11 = matrix[..., 1, 1] + m22 = matrix[..., 2, 2] + o0 = 0.5 * _sqrt_positive_part(1 + m00 + m11 + m22) + x = 0.5 * _sqrt_positive_part(1 + m00 - m11 - m22) + y = 0.5 * _sqrt_positive_part(1 - m00 + m11 - m22) + z = 0.5 * _sqrt_positive_part(1 - m00 - m11 + m22) + o1 = _copysign(x, matrix[..., 2, 1] - matrix[..., 1, 2]) + o2 = _copysign(y, matrix[..., 0, 2] - matrix[..., 2, 0]) + o3 = _copysign(z, matrix[..., 1, 0] - matrix[..., 0, 1]) + return torch.stack((o0, o1, o2, o3), -1) + + +def _axis_angle_rotation(axis: str, angle): + """ + Return the rotation matrices for one of the rotations about an axis + of which Euler angles describe, for each value of the angle given. + Args: + axis: Axis label "X" or "Y or "Z". + angle: any shape tensor of Euler angles in radians + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + + cos = torch.cos(angle) + sin = torch.sin(angle) + one = torch.ones_like(angle) + zero = torch.zeros_like(angle) + + if axis == "X": + R_flat = (one, zero, zero, zero, cos, -sin, zero, sin, cos) + if axis == "Y": + R_flat = (cos, zero, sin, zero, one, zero, -sin, zero, cos) + if axis == "Z": + R_flat = (cos, -sin, zero, sin, cos, zero, zero, zero, one) + + return torch.stack(R_flat, -1).reshape(angle.shape + (3, 3)) + + +def euler_angles_to_matrix(euler_angles, convention: str): + """ + Convert rotations given as Euler angles in radians to rotation matrices. + Args: + euler_angles: Euler angles in radians as tensor of shape (..., 3). + convention: Convention string of three uppercase letters from + {"X", "Y", and "Z"}. + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + if euler_angles.dim() == 0 or euler_angles.shape[-1] != 3: + raise ValueError("Invalid input euler angles.") + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + matrices = map(_axis_angle_rotation, convention, torch.unbind(euler_angles, -1)) + return functools.reduce(torch.matmul, matrices) + + +def _angle_from_tan( + axis: str, other_axis: str, data, horizontal: bool, tait_bryan: bool +): + """ + Extract the first or third Euler angle from the two members of + the matrix which are positive constant times its sine and cosine. + Args: + axis: Axis label "X" or "Y or "Z" for the angle we are finding. + other_axis: Axis label "X" or "Y or "Z" for the middle axis in the + convention. + data: Rotation matrices as tensor of shape (..., 3, 3). + horizontal: Whether we are looking for the angle for the third axis, + which means the relevant entries are in the same row of the + rotation matrix. If not, they are in the same column. + tait_bryan: Whether the first and third axes in the convention differ. + Returns: + Euler Angles in radians for each matrix in data as a tensor + of shape (...). + """ + + i1, i2 = {"X": (2, 1), "Y": (0, 2), "Z": (1, 0)}[axis] + if horizontal: + i2, i1 = i1, i2 + even = (axis + other_axis) in ["XY", "YZ", "ZX"] + if horizontal == even: + return torch.atan2(data[..., i1], data[..., i2]) + if tait_bryan: + return torch.atan2(-data[..., i2], data[..., i1]) + return torch.atan2(data[..., i2], -data[..., i1]) + + +def _index_from_letter(letter: str): + if letter == "X": + return 0 + if letter == "Y": + return 1 + if letter == "Z": + return 2 + + +def matrix_to_euler_angles(matrix, convention: str): + """ + Convert rotations given as rotation matrices to Euler angles in radians. + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + convention: Convention string of three uppercase letters. + Returns: + Euler angles in radians as tensor of shape (..., 3). + """ + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape f{matrix.shape}.") + i0 = _index_from_letter(convention[0]) + i2 = _index_from_letter(convention[2]) + tait_bryan = i0 != i2 + if tait_bryan: + central_angle = torch.asin( + matrix[..., i0, i2] * (-1.0 if i0 - i2 in [-1, 2] else 1.0) + ) + else: + central_angle = torch.acos(matrix[..., i0, i0]) + + o = ( + _angle_from_tan( + convention[0], convention[1], matrix[..., i2], False, tait_bryan + ), + central_angle, + _angle_from_tan( + convention[2], convention[1], matrix[..., i0, :], True, tait_bryan + ), + ) + return torch.stack(o, -1) + + +def random_quaternions( + n: int, dtype: Optional[torch.dtype] = None, device=None, requires_grad=False +): + """ + Generate random quaternions representing rotations, + i.e. versors with nonnegative real part. + Args: + n: Number of quaternions in a batch to return. + dtype: Type to return. + device: Desired device of returned tensor. Default: + uses the current device for the default tensor type. + requires_grad: Whether the resulting tensor should have the gradient + flag set. + Returns: + Quaternions as tensor of shape (N, 4). + """ + o = torch.randn((n, 4), dtype=dtype, device=device, requires_grad=requires_grad) + s = (o * o).sum(1) + o = o / _copysign(torch.sqrt(s), o[:, 0])[:, None] + return o + + +def random_rotations( + n: int, dtype: Optional[torch.dtype] = None, device=None, requires_grad=False +): + """ + Generate random rotations as 3x3 rotation matrices. + Args: + n: Number of rotation matrices in a batch to return. + dtype: Type to return. + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type. + requires_grad: Whether the resulting tensor should have the gradient + flag set. + Returns: + Rotation matrices as tensor of shape (n, 3, 3). + """ + quaternions = random_quaternions( + n, dtype=dtype, device=device, requires_grad=requires_grad + ) + return quaternion_to_matrix(quaternions) + + +def random_rotation( + dtype: Optional[torch.dtype] = None, device=None, requires_grad=False +): + """ + Generate a single random 3x3 rotation matrix. + Args: + dtype: Type to return + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type + requires_grad: Whether the resulting tensor should have the gradient + flag set + Returns: + Rotation matrix as tensor of shape (3, 3). + """ + return random_rotations(1, dtype, device, requires_grad)[0] + + +def standardize_quaternion(quaternions): + """ + Convert a unit quaternion to a standard form: one in which the real + part is non negative. + Args: + quaternions: Quaternions with real part first, + as tensor of shape (..., 4). + Returns: + Standardized quaternions as tensor of shape (..., 4). + """ + return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions) + + +def quaternion_raw_multiply(a, b): + """ + Multiply two quaternions. + Usual torch rules for broadcasting apply. + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + Returns: + The product of a and b, a tensor of quaternions shape (..., 4). + """ + aw, ax, ay, az = torch.unbind(a, -1) + bw, bx, by, bz = torch.unbind(b, -1) + ow = aw * bw - ax * bx - ay * by - az * bz + ox = aw * bx + ax * bw + ay * bz - az * by + oy = aw * by - ax * bz + ay * bw + az * bx + oz = aw * bz + ax * by - ay * bx + az * bw + return torch.stack((ow, ox, oy, oz), -1) + + +def quaternion_multiply(a, b): + """ + Multiply two quaternions representing rotations, returning the quaternion + representing their composition, i.e. the versor with nonnegative real part. + Usual torch rules for broadcasting apply. + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + Returns: + The product of a and b, a tensor of quaternions of shape (..., 4). + """ + ab = quaternion_raw_multiply(a, b) + return standardize_quaternion(ab) + + +def quaternion_invert(quaternion): + """ + Given a quaternion representing rotation, get the quaternion representing + its inverse. + Args: + quaternion: Quaternions as tensor of shape (..., 4), with real part + first, which must be versors (unit quaternions). + Returns: + The inverse, a tensor of quaternions of shape (..., 4). + """ + + return quaternion * quaternion.new_tensor([1, -1, -1, -1]) + + +def quaternion_apply(quaternion, point): + """ + Apply the rotation given by a quaternion to a 3D point. + Usual torch rules for broadcasting apply. + Args: + quaternion: Tensor of quaternions, real part first, of shape (..., 4). + point: Tensor of 3D points of shape (..., 3). + Returns: + Tensor of rotated points of shape (..., 3). + """ + if point.size(-1) != 3: + raise ValueError(f"Points are not in 3D, f{point.shape}.") + real_parts = point.new_zeros(point.shape[:-1] + (1,)) + point_as_quaternion = torch.cat((real_parts, point), -1) + out = quaternion_raw_multiply( + quaternion_raw_multiply(quaternion, point_as_quaternion), + quaternion_invert(quaternion), + ) + return out[..., 1:] + + +def axis_angle_to_matrix(axis_angle): + """ + Convert rotations given as axis/angle to rotation matrices. + Args: + axis_angle: Rotations given as a vector in axis angle form, + as a tensor of shape (..., 3), where the magnitude is + the angle turned anticlockwise in radians around the + vector's direction. + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + return quaternion_to_matrix(axis_angle_to_quaternion(axis_angle)) + + +def matrix_to_axis_angle(matrix): + """ + Convert rotations given as rotation matrices to axis/angle. + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + Returns: + Rotations given as a vector in axis angle form, as a tensor + of shape (..., 3), where the magnitude is the angle + turned anticlockwise in radians around the vector's + direction. + """ + return quaternion_to_axis_angle(matrix_to_quaternion(matrix)) + + +def axis_angle_to_quaternion(axis_angle): + """ + Convert rotations given as axis/angle to quaternions. + Args: + axis_angle: Rotations given as a vector in axis angle form, + as a tensor of shape (..., 3), where the magnitude is + the angle turned anticlockwise in radians around the + vector's direction. + Returns: + quaternions with real part first, as tensor of shape (..., 4). + """ + angles = torch.norm(axis_angle, p=2, dim=-1, keepdim=True) + half_angles = 0.5 * angles + eps = 1e-6 + small_angles = angles.abs() < eps + sin_half_angles_over_angles = torch.empty_like(angles) + sin_half_angles_over_angles[~small_angles] = ( + torch.sin(half_angles[~small_angles]) / angles[~small_angles] + ) + # for x small, sin(x/2) is about x/2 - (x/2)^3/6 + # so sin(x/2)/x is about 1/2 - (x*x)/48 + sin_half_angles_over_angles[small_angles] = ( + 0.5 - (angles[small_angles] * angles[small_angles]) / 48 + ) + quaternions = torch.cat( + [torch.cos(half_angles), axis_angle * sin_half_angles_over_angles], dim=-1 + ) + return quaternions + + +def quaternion_to_axis_angle(quaternions): + """ + Convert rotations given as quaternions to axis/angle. + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + Returns: + Rotations given as a vector in axis angle form, as a tensor + of shape (..., 3), where the magnitude is the angle + turned anticlockwise in radians around the vector's + direction. + """ + norms = torch.norm(quaternions[..., 1:], p=2, dim=-1, keepdim=True) + half_angles = torch.atan2(norms, quaternions[..., :1]) + angles = 2 * half_angles + eps = 1e-6 + small_angles = angles.abs() < eps + sin_half_angles_over_angles = torch.empty_like(angles) + sin_half_angles_over_angles[~small_angles] = ( + torch.sin(half_angles[~small_angles]) / angles[~small_angles] + ) + # for x small, sin(x/2) is about x/2 - (x/2)^3/6 + # so sin(x/2)/x is about 1/2 - (x*x)/48 + sin_half_angles_over_angles[small_angles] = ( + 0.5 - (angles[small_angles] * angles[small_angles]) / 48 + ) + return quaternions[..., 1:] / sin_half_angles_over_angles + + +def rotation_6d_to_matrix(d6: torch.Tensor) -> torch.Tensor: + """ + Converts 6D rotation representation by Zhou et al. [1] to rotation matrix + using Gram--Schmidt orthogonalisation per Section B of [1]. + Args: + d6: 6D rotation representation, of size (*, 6) + Returns: + batch of rotation matrices of size (*, 3, 3) + [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H. + On the Continuity of Rotation Representations in Neural Networks. + IEEE Conference on Computer Vision and Pattern Recognition, 2019. + Retrieved from http://arxiv.org/abs/1812.07035 + """ + + a1, a2 = d6[..., :3], d6[..., 3:] + b1 = F.normalize(a1, dim=-1) + b2 = a2 - (b1 * a2).sum(-1, keepdim=True) * b1 + b2 = F.normalize(b2, dim=-1) + b3 = torch.cross(b1, b2, dim=-1) + return torch.stack((b1, b2, b3), dim=-2) + + +def matrix_to_rotation_6d(matrix: torch.Tensor) -> torch.Tensor: + """ + Converts rotation matrices to 6D rotation representation by Zhou et al. [1] + by dropping the last row. Note that 6D representation is not unique. + Args: + matrix: batch of rotation matrices of size (*, 3, 3) + Returns: + 6D rotation representation, of size (*, 6) + [1] Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H. + On the Continuity of Rotation Representations in Neural Networks. + IEEE Conference on Computer Vision and Pattern Recognition, 2019. + Retrieved from http://arxiv.org/abs/1812.07035 + """ + return matrix[..., :2, :].clone().reshape(*matrix.size()[:-2], 6) + +def canonicalize_smplh(poses, trans = None): + bs, nframes, njoints = poses.shape[:3] + + global_orient = poses[:, :, 0] + + # first global rotations + rot2d = matrix_to_axis_angle(global_orient[:, 0]) + #rot2d[:, :2] = 0 # Remove the rotation along the vertical axis + rot2d = axis_angle_to_matrix(rot2d) + + # Rotate the global rotation to eliminate Z rotations + global_orient = torch.einsum("ikj,imkl->imjl", rot2d, global_orient) + + # Construct canonicalized version of x + xc = torch.cat((global_orient[:, :, None], poses[:, :, 1:]), dim=2) + + if trans is not None: + vel = trans[:, 1:] - trans[:, :-1] + # Turn the translation as well + vel = torch.einsum("ikj,ilk->ilj", rot2d, vel) + trans = torch.cat((torch.zeros(bs, 1, 3, device=vel.device), + torch.cumsum(vel, 1)), 1) + return xc, trans + else: + return xc + + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/skeleton.py b/MuseV/MMCM/mmcm/t2p/utils/skeleton.py new file mode 100755 index 0000000000000000000000000000000000000000..b2ae85ad14df8c1a8d77e689b1cffbc6c814a979 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/skeleton.py @@ -0,0 +1,199 @@ +from .quaternion import * +import scipy.ndimage.filters as filters + +class Skeleton(object): + def __init__(self, offset, kinematic_tree, device): + self.device = device + self._raw_offset_np = offset.numpy() + self._raw_offset = offset.clone().detach().to(device).float() + self._kinematic_tree = kinematic_tree + self._offset = None + self._parents = [0] * len(self._raw_offset) + self._parents[0] = -1 + for chain in self._kinematic_tree: + for j in range(1, len(chain)): + self._parents[chain[j]] = chain[j-1] + + def njoints(self): + return len(self._raw_offset) + + def offset(self): + return self._offset + + def set_offset(self, offsets): + self._offset = offsets.clone().detach().to(self.device).float() + + def kinematic_tree(self): + return self._kinematic_tree + + def parents(self): + return self._parents + + # joints (batch_size, joints_num, 3) + def get_offsets_joints_batch(self, joints): + assert len(joints.shape) == 3 + _offsets = self._raw_offset.expand(joints.shape[0], -1, -1).clone() + for i in range(1, self._raw_offset.shape[0]): + _offsets[:, i] = torch.norm(joints[:, i] - joints[:, self._parents[i]], p=2, dim=1)[:, None] * _offsets[:, i] + + self._offset = _offsets.detach() + return _offsets + + # joints (joints_num, 3) + def get_offsets_joints(self, joints): + assert len(joints.shape) == 2 + _offsets = self._raw_offset.clone() + for i in range(1, self._raw_offset.shape[0]): + # print(joints.shape) + _offsets[i] = torch.norm(joints[i] - joints[self._parents[i]], p=2, dim=0) * _offsets[i] + + self._offset = _offsets.detach() + return _offsets + + # face_joint_idx should follow the order of right hip, left hip, right shoulder, left shoulder + # joints (batch_size, joints_num, 3) + def inverse_kinematics_np(self, joints, face_joint_idx, smooth_forward=False): + assert len(face_joint_idx) == 4 + '''Get Forward Direction''' + l_hip, r_hip, sdr_r, sdr_l = face_joint_idx + across1 = joints[:, r_hip] - joints[:, l_hip] + across2 = joints[:, sdr_r] - joints[:, sdr_l] + across = across1 + across2 + across = across / np.sqrt((across**2).sum(axis=-1))[:, np.newaxis] + # print(across1.shape, across2.shape) + + # forward (batch_size, 3) + forward = np.cross(np.array([[0, 1, 0]]), across, axis=-1) + if smooth_forward: + forward = filters.gaussian_filter1d(forward, 20, axis=0, mode='nearest') + # forward (batch_size, 3) + forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis] + + '''Get Root Rotation''' + target = np.array([[0,0,1]]).repeat(len(forward), axis=0) + root_quat = qbetween_np(forward, target) + + '''Inverse Kinematics''' + # quat_params (batch_size, joints_num, 4) + # print(joints.shape[:-1]) + quat_params = np.zeros(joints.shape[:-1] + (4,)) + # print(quat_params.shape) + root_quat[0] = np.array([[1.0, 0.0, 0.0, 0.0]]) + quat_params[:, 0] = root_quat + # quat_params[0, 0] = np.array([[1.0, 0.0, 0.0, 0.0]]) + for chain in self._kinematic_tree: + R = root_quat + for j in range(len(chain) - 1): + # (batch, 3) + u = self._raw_offset_np[chain[j+1]][np.newaxis,...].repeat(len(joints), axis=0) + # print(u.shape) + # (batch, 3) + v = joints[:, chain[j+1]] - joints[:, chain[j]] + v = v / np.sqrt((v**2).sum(axis=-1))[:, np.newaxis] + # print(u.shape, v.shape) + rot_u_v = qbetween_np(u, v) + + R_loc = qmul_np(qinv_np(R), rot_u_v) + + quat_params[:,chain[j + 1], :] = R_loc + R = qmul_np(R, R_loc) + + return quat_params + + # Be sure root joint is at the beginning of kinematic chains + def forward_kinematics(self, quat_params, root_pos, skel_joints=None, do_root_R=True): + # quat_params (batch_size, joints_num, 4) + # joints (batch_size, joints_num, 3) + # root_pos (batch_size, 3) + if skel_joints is not None: + offsets = self.get_offsets_joints_batch(skel_joints) + if len(self._offset.shape) == 2: + offsets = self._offset.expand(quat_params.shape[0], -1, -1) + joints = torch.zeros(quat_params.shape[:-1] + (3,)).to(self.device) + joints[:, 0] = root_pos + for chain in self._kinematic_tree: + if do_root_R: + R = quat_params[:, 0] + else: + R = torch.tensor([[1.0, 0.0, 0.0, 0.0]]).expand(len(quat_params), -1).detach().to(self.device) + for i in range(1, len(chain)): + R = qmul(R, quat_params[:, chain[i]]) + offset_vec = offsets[:, chain[i]] + joints[:, chain[i]] = qrot(R, offset_vec) + joints[:, chain[i-1]] + return joints + + # Be sure root joint is at the beginning of kinematic chains + def forward_kinematics_np(self, quat_params, root_pos, skel_joints=None, do_root_R=True): + # quat_params (batch_size, joints_num, 4) + # joints (batch_size, joints_num, 3) + # root_pos (batch_size, 3) + if skel_joints is not None: + skel_joints = torch.from_numpy(skel_joints) + offsets = self.get_offsets_joints_batch(skel_joints) + if len(self._offset.shape) == 2: + offsets = self._offset.expand(quat_params.shape[0], -1, -1) + offsets = offsets.numpy() + joints = np.zeros(quat_params.shape[:-1] + (3,)) + joints[:, 0] = root_pos + for chain in self._kinematic_tree: + if do_root_R: + R = quat_params[:, 0] + else: + R = np.array([[1.0, 0.0, 0.0, 0.0]]).repeat(len(quat_params), axis=0) + for i in range(1, len(chain)): + R = qmul_np(R, quat_params[:, chain[i]]) + offset_vec = offsets[:, chain[i]] + joints[:, chain[i]] = qrot_np(R, offset_vec) + joints[:, chain[i - 1]] + return joints + + def forward_kinematics_cont6d_np(self, cont6d_params, root_pos, skel_joints=None, do_root_R=True): + # cont6d_params (batch_size, joints_num, 6) + # joints (batch_size, joints_num, 3) + # root_pos (batch_size, 3) + if skel_joints is not None: + skel_joints = torch.from_numpy(skel_joints) + offsets = self.get_offsets_joints_batch(skel_joints) + if len(self._offset.shape) == 2: + offsets = self._offset.expand(cont6d_params.shape[0], -1, -1) + offsets = offsets.numpy() + joints = np.zeros(cont6d_params.shape[:-1] + (3,)) + joints[:, 0] = root_pos + for chain in self._kinematic_tree: + if do_root_R: + matR = cont6d_to_matrix_np(cont6d_params[:, 0]) + else: + matR = np.eye(3)[np.newaxis, :].repeat(len(cont6d_params), axis=0) + for i in range(1, len(chain)): + matR = np.matmul(matR, cont6d_to_matrix_np(cont6d_params[:, chain[i]])) + offset_vec = offsets[:, chain[i]][..., np.newaxis] + # print(matR.shape, offset_vec.shape) + joints[:, chain[i]] = np.matmul(matR, offset_vec).squeeze(-1) + joints[:, chain[i-1]] + return joints + + def forward_kinematics_cont6d(self, cont6d_params, root_pos, skel_joints=None, do_root_R=True): + # cont6d_params (batch_size, joints_num, 6) + # joints (batch_size, joints_num, 3) + # root_pos (batch_size, 3) + if skel_joints is not None: + # skel_joints = torch.from_numpy(skel_joints) + offsets = self.get_offsets_joints_batch(skel_joints) + if len(self._offset.shape) == 2: + offsets = self._offset.expand(cont6d_params.shape[0], -1, -1) + joints = torch.zeros(cont6d_params.shape[:-1] + (3,)).to(cont6d_params.device) + joints[..., 0, :] = root_pos + for chain in self._kinematic_tree: + if do_root_R: + matR = cont6d_to_matrix(cont6d_params[:, 0]) + else: + matR = torch.eye(3).expand((len(cont6d_params), -1, -1)).detach().to(cont6d_params.device) + for i in range(1, len(chain)): + matR = torch.matmul(matR, cont6d_to_matrix(cont6d_params[:, chain[i]])) + offset_vec = offsets[:, chain[i]].unsqueeze(-1) + # print(matR.shape, offset_vec.shape) + joints[:, chain[i]] = torch.matmul(matR, offset_vec).squeeze(-1) + joints[:, chain[i-1]] + return joints + + + + + diff --git a/MuseV/MMCM/mmcm/t2p/utils/utils_model.py b/MuseV/MMCM/mmcm/t2p/utils/utils_model.py new file mode 100755 index 0000000000000000000000000000000000000000..b3653a47ddb96f2ba27aae73b4eef8be904e9bf0 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/utils_model.py @@ -0,0 +1,66 @@ +import numpy as np +import torch +import torch.optim as optim +import logging +import os +import sys + +def getCi(accLog): + + mean = np.mean(accLog) + std = np.std(accLog) + ci95 = 1.96*std/np.sqrt(len(accLog)) + + return mean, ci95 + +def get_logger(out_dir): + logger = logging.getLogger('Exp') + logger.setLevel(logging.INFO) + formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s") + + file_path = os.path.join(out_dir, "run.log") + file_hdlr = logging.FileHandler(file_path) + file_hdlr.setFormatter(formatter) + + strm_hdlr = logging.StreamHandler(sys.stdout) + strm_hdlr.setFormatter(formatter) + + logger.addHandler(file_hdlr) + logger.addHandler(strm_hdlr) + return logger + +## Optimizer +def initial_optim(decay_option, lr, weight_decay, net, optimizer) : + + if optimizer == 'adamw' : + optimizer_adam_family = optim.AdamW + elif optimizer == 'adam' : + optimizer_adam_family = optim.Adam + if decay_option == 'all': + #optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=weight_decay) + optimizer = optimizer_adam_family(net.parameters(), lr=lr, betas=(0.5, 0.9), weight_decay=weight_decay) + + elif decay_option == 'noVQ': + all_params = set(net.parameters()) + no_decay = set([net.vq_layer]) + + decay = all_params - no_decay + optimizer = optimizer_adam_family([ + {'params': list(no_decay), 'weight_decay': 0}, + {'params': list(decay), 'weight_decay' : weight_decay}], lr=lr) + + return optimizer + + +def get_motion_with_trans(motion, velocity) : + ''' + motion : torch.tensor, shape (batch_size, T, 72), with the global translation = 0 + velocity : torch.tensor, shape (batch_size, T, 3), contain the information of velocity = 0 + + ''' + trans = torch.cumsum(velocity, dim=1) + trans = trans - trans[:, :1] ## the first root is initialized at 0 (just for visualization) + trans = trans.repeat((1, 1, 21)) + motion_with_trans = motion + trans + return motion_with_trans + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/utils/word_vectorizer.py b/MuseV/MMCM/mmcm/t2p/utils/word_vectorizer.py new file mode 100755 index 0000000000000000000000000000000000000000..557ff97a9539c084167f3eca51fb50f53f33c8ea --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/utils/word_vectorizer.py @@ -0,0 +1,99 @@ +import numpy as np +import pickle +from os.path import join as pjoin + +POS_enumerator = { + 'VERB': 0, + 'NOUN': 1, + 'DET': 2, + 'ADP': 3, + 'NUM': 4, + 'AUX': 5, + 'PRON': 6, + 'ADJ': 7, + 'ADV': 8, + 'Loc_VIP': 9, + 'Body_VIP': 10, + 'Obj_VIP': 11, + 'Act_VIP': 12, + 'Desc_VIP': 13, + 'OTHER': 14, +} + +Loc_list = ('left', 'right', 'clockwise', 'counterclockwise', 'anticlockwise', 'forward', 'back', 'backward', + 'up', 'down', 'straight', 'curve') + +Body_list = ('arm', 'chin', 'foot', 'feet', 'face', 'hand', 'mouth', 'leg', 'waist', 'eye', 'knee', 'shoulder', 'thigh') + +Obj_List = ('stair', 'dumbbell', 'chair', 'window', 'floor', 'car', 'ball', 'handrail', 'baseball', 'basketball') + +Act_list = ('walk', 'run', 'swing', 'pick', 'bring', 'kick', 'put', 'squat', 'throw', 'hop', 'dance', 'jump', 'turn', + 'stumble', 'dance', 'stop', 'sit', 'lift', 'lower', 'raise', 'wash', 'stand', 'kneel', 'stroll', + 'rub', 'bend', 'balance', 'flap', 'jog', 'shuffle', 'lean', 'rotate', 'spin', 'spread', 'climb') + +Desc_list = ('slowly', 'carefully', 'fast', 'careful', 'slow', 'quickly', 'happy', 'angry', 'sad', 'happily', + 'angrily', 'sadly') + +VIP_dict = { + 'Loc_VIP': Loc_list, + 'Body_VIP': Body_list, + 'Obj_VIP': Obj_List, + 'Act_VIP': Act_list, + 'Desc_VIP': Desc_list, +} + + +class WordVectorizer(object): + def __init__(self, meta_root, prefix): + vectors = np.load(pjoin(meta_root, '%s_data.npy'%prefix)) + words = pickle.load(open(pjoin(meta_root, '%s_words.pkl'%prefix), 'rb')) + self.word2idx = pickle.load(open(pjoin(meta_root, '%s_idx.pkl'%prefix), 'rb')) + self.word2vec = {w: vectors[self.word2idx[w]] for w in words} + + def _get_pos_ohot(self, pos): + pos_vec = np.zeros(len(POS_enumerator)) + if pos in POS_enumerator: + pos_vec[POS_enumerator[pos]] = 1 + else: + pos_vec[POS_enumerator['OTHER']] = 1 + return pos_vec + + def __len__(self): + return len(self.word2vec) + + def __getitem__(self, item): + word, pos = item.split('/') + if word in self.word2vec: + word_vec = self.word2vec[word] + vip_pos = None + for key, values in VIP_dict.items(): + if word in values: + vip_pos = key + break + if vip_pos is not None: + pos_vec = self._get_pos_ohot(vip_pos) + else: + pos_vec = self._get_pos_ohot(pos) + else: + word_vec = self.word2vec['unk'] + pos_vec = self._get_pos_ohot('OTHER') + return word_vec, pos_vec + + +class WordVectorizerV2(WordVectorizer): + def __init__(self, meta_root, prefix): + super(WordVectorizerV2, self).__init__(meta_root, prefix) + self.idx2word = {self.word2idx[w]: w for w in self.word2idx} + + def __getitem__(self, item): + word_vec, pose_vec = super(WordVectorizerV2, self).__getitem__(item) + word, pos = item.split('/') + if word in self.word2vec: + return word_vec, pose_vec, self.word2idx[word] + else: + return word_vec, pose_vec, self.word2idx['unk'] + + def itos(self, idx): + if idx == len(self.idx2word): + return "pad" + return self.idx2word[idx] \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/visualization/plot_3d_global.py b/MuseV/MMCM/mmcm/t2p/visualization/plot_3d_global.py new file mode 100755 index 0000000000000000000000000000000000000000..9f163a5b67c8a98cc259a8c8c4e435d0646ab48f --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualization/plot_3d_global.py @@ -0,0 +1,131 @@ +import torch +import matplotlib.pyplot as plt +import numpy as np +import io +import matplotlib +from mpl_toolkits.mplot3d.art3d import Poly3DCollection +import mpl_toolkits.mplot3d.axes3d as p3 +from textwrap import wrap +import imageio + +def plot_3d_motion(args, figsize=(10, 10), fps=120, radius=4): + matplotlib.use('Agg') + + plt.style.use('dark_background') + joints, out_name, title = args #kit(192,22,3) + + data = joints.copy().reshape(len(joints), -1, 3) + + nb_joints = joints.shape[1]# kit:22 openpose 25 + smpl_kinetic_chain = [[0, 11, 12, 13, 14, 15], [0, 16, 17, 18, 19, 20], [0, 1, 2, 3, 4], [3, 5, 6, 7], [3, 8, 9, 10]] if nb_joints == 21 else [[0, 2, 5, 8, 11], [0, 1, 4, 7, 10], [0, 3, 6, 9, 12, 15], [9, 14, 17, 19, 21], [9, 13, 16, 18, 20]] + # 22关键点 [0, 2, 5, 8, 11]表示连接了五个关键点，分别是左脚踝（0号关键点）、左髋部（2号关键点）、左肩部（5号关键点）、左手腕（8号关键点）和左肘部（11号关键点），这五个关键点按照顺序连接起来。 + # [0, 11, 12, 13, 14, 15]表示连接了六个关键点，分别是骨盆（0号关键点）、左大腿（11号关键点）、左小腿（12号关键点）、左脚踝（13号关键点）、左脚尖（14号关键点）和左脚掌（15号关键点 + limits = 1000 if nb_joints == 21 else 2 + MINS = data.min(axis=0).min(axis=0) + MAXS = data.max(axis=0).max(axis=0) + colors = ['red', 'blue', 'black', 'red', 'blue', + 'darkblue', 'darkblue', 'darkblue', 'darkblue', 'darkblue', + 'darkred', 'darkred', 'darkred', 'darkred', 'darkred'] + frame_number = data.shape[0] + # print(data.shape) + + height_offset = MINS[1] + data[:, :, 1] -= height_offset + trajec = data[:, 0, [0, 2]] + + data[..., 0] -= data[:, 0:1, 0] + data[..., 2] -= data[:, 0:1, 2] + + def update(index): + + def init(): + ax.set_xlim(-limits, limits) + ax.set_ylim(-limits, limits) + ax.set_zlim(0, limits) + ax.grid(b=False) + def plot_xzPlane(minx, maxx, miny, minz, maxz): + ## Plot a plane XZ + verts = [ + [minx, miny, minz], + [minx, miny, maxz], + [maxx, miny, maxz], + [maxx, miny, minz] + ] + xz_plane = Poly3DCollection([verts]) + xz_plane.set_facecolor((0.5, 0.5, 0.5, 0.5)) + #xz_plane.set_facecolor(()) + #ax.add_collection3d(xz_plane)#绘制行走平面 + fig = plt.figure(figsize=(480/96., 320/96.), dpi=96) if nb_joints == 21 else plt.figure(figsize=(10, 10), dpi=96) + if title is not None : + wraped_title = '\n'.join(wrap(title, 40)) + fig.suptitle(wraped_title, fontsize=16) + ax = p3.Axes3D(fig) + + init() + + #ax.lines = [] + #ax.collections = [] + ax.view_init(elev=110, azim=-90) + ax.dist = 7.5 + # ax = + plot_xzPlane(MINS[0] - trajec[index, 0], MAXS[0] - trajec[index, 0], 0, MINS[2] - trajec[index, 1], + MAXS[2] - trajec[index, 1]) + # ax.scatter(data[index, :22, 0], data[index, :22, 1], data[index, :22, 2], color='black', s=3) + + if index > 1: + ax.plot3D(trajec[:index, 0] - trajec[index, 0], np.zeros_like(trajec[:index, 0]), + trajec[:index, 1] - trajec[index, 1], linewidth=1.0, + color='blue') + # ax = plot_xzPlane(ax, MINS[0], MAXS[0], 0, MINS[2], MAXS[2]) + + for i, (chain, color) in enumerate(zip(smpl_kinetic_chain, colors)): + + if i < 5: + linewidth = 4.0 + else: + linewidth = 2.0 + ax.plot3D(data[index, chain, 0], data[index, chain, 1], data[index, chain, 2], linewidth=linewidth,color=color)#xyz width color + #ax.text(data[index, chain, 0], data[index, chain, 1], data[index, chain, 2], str(chain), fontsize = 15) + plt.axis('off') + ax.set_xticklabels([]) + ax.set_yticklabels([]) + ax.set_zticklabels([]) + + #plt.savefig(f'./smpl_{index}.jpg', dpi=96) + if out_name is not None : + plt.savefig(out_name, dpi=96) + plt.close() + + else : + io_buf = io.BytesIO() + fig.savefig(io_buf, format='raw', dpi=96) + io_buf.seek(0) + # print(fig.bbox.bounds) + arr = np.reshape(np.frombuffer(io_buf.getvalue(), dtype=np.uint8), + newshape=(int(fig.bbox.bounds[3]), int(fig.bbox.bounds[2]), -1)) + io_buf.close() + plt.close() + return arr + + out = [] + for i in range(frame_number) : + out.append(update(i)) + out = np.stack(out, axis=0) + return torch.from_numpy(out) + + +def draw_to_batch(smpl_joints_batch, title_batch=None, outname=None) : + + batch_size = len(smpl_joints_batch) + out = [] + for i in range(batch_size) : + out.append(plot_3d_motion([smpl_joints_batch[i], None, title_batch[i] if title_batch is not None else None])) + if outname is not None: + imageio.mimsave(outname[i], np.array(out[-1]), duration=1000/20) + out = torch.stack(out, axis=0) + return out + + + + + diff --git a/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/config.py b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/config.py new file mode 100755 index 0000000000000000000000000000000000000000..a08aa5f905d18e87932ab0de283ecbef11d1c057 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/config.py @@ -0,0 +1,40 @@ +import numpy as np + +# Map joints Name to SMPL joints idx +JOINT_MAP = { +'MidHip': 0, +'LHip': 1, 'LKnee': 4, 'LAnkle': 7, 'LFoot': 10, +'RHip': 2, 'RKnee': 5, 'RAnkle': 8, 'RFoot': 11, +'LShoulder': 16, 'LElbow': 18, 'LWrist': 20, 'LHand': 22, +'RShoulder': 17, 'RElbow': 19, 'RWrist': 21, 'RHand': 23, +'spine1': 3, 'spine2': 6, 'spine3': 9, 'Neck': 12, 'Head': 15, +'LCollar':13, 'Rcollar' :14, +'Nose':24, 'REye':26, 'LEye':26, 'REar':27, 'LEar':28, +'LHeel': 31, 'RHeel': 34, +'OP RShoulder': 17, 'OP LShoulder': 16, +'OP RHip': 2, 'OP LHip': 1, +'OP Neck': 12, +} + +full_smpl_idx = range(24) +key_smpl_idx = [0, 1, 4, 7, 2, 5, 8, 17, 19, 21, 16, 18, 20] + + +AMASS_JOINT_MAP = { +'MidHip': 0, +'LHip': 1, 'LKnee': 4, 'LAnkle': 7, 'LFoot': 10, +'RHip': 2, 'RKnee': 5, 'RAnkle': 8, 'RFoot': 11, +'LShoulder': 16, 'LElbow': 18, 'LWrist': 20, +'RShoulder': 17, 'RElbow': 19, 'RWrist': 21, +'spine1': 3, 'spine2': 6, 'spine3': 9, 'Neck': 12, 'Head': 15, +'LCollar':13, 'Rcollar' :14, +} +amass_idx = range(22) +amass_smpl_idx = range(22) + + +SMPL_MODEL_DIR = "/group/30065/users/zhanchao/code/MMCM/mmcm/t2p/body_models/" +GMM_MODEL_DIR = "/group/30065/users/zhanchao/code/MMCM/mmcm/t2p/visualize/joints2smpl/smpl_models" +SMPL_MEAN_FILE = "/group/30065/users/zhanchao/code/MMCM/mmcm/t2p/visualize/joints2smpl/smpl_models/neutral_smpl_mean_params.h5" +# for collsion +Part_Seg_DIR = "/group/30065/users/zhanchao/code/MMCM/mmcm/t2p/visualize/joints2smpl/smpl_models/smplx_parts_segm.pkl" \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/customloss.py b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/customloss.py new file mode 100755 index 0000000000000000000000000000000000000000..18b88ccce9263715a077058a4ade1056e9ff6c96 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/customloss.py @@ -0,0 +1,224 @@ +from __future__ import absolute_import + +import torch +import torch.nn.functional as F +from mmcm.t2p.visualize.joints2smpl.src import config + +# Guassian +def gmof(x, sigma): + """ + Geman-McClure error function + """ + x_squared = x ** 2 + sigma_squared = sigma ** 2 + return (sigma_squared * x_squared) / (sigma_squared + x_squared) + +# angle prior +def angle_prior(pose): + """ + Angle prior that penalizes unnatural bending of the knees and elbows + """ + # We subtract 3 because pose does not include the global rotation of the model + return torch.exp( + pose[:, [55 - 3, 58 - 3, 12 - 3, 15 - 3]] * torch.tensor([1., -1., -1, -1.], device=pose.device)) ** 2 + + +def perspective_projection(points, rotation, translation, + focal_length, camera_center): + """ + This function computes the perspective projection of a set of points. + Input: + points (bs, N, 3): 3D points + rotation (bs, 3, 3): Camera rotation + translation (bs, 3): Camera translation + focal_length (bs,) or scalar: Focal length + camera_center (bs, 2): Camera center + """ + batch_size = points.shape[0] + K = torch.zeros([batch_size, 3, 3], device=points.device) + K[:, 0, 0] = focal_length + K[:, 1, 1] = focal_length + K[:, 2, 2] = 1. + K[:, :-1, -1] = camera_center + + # Transform points + points = torch.einsum('bij,bkj->bki', rotation, points) + points = points + translation.unsqueeze(1) + + # Apply perspective distortion + projected_points = points / points[:, :, -1].unsqueeze(-1) + + # Apply camera intrinsics + projected_points = torch.einsum('bij,bkj->bki', K, projected_points) + + return projected_points[:, :, :-1] + + +def body_fitting_loss(body_pose, betas, model_joints, camera_t, camera_center, + joints_2d, joints_conf, pose_prior, + focal_length=5000, sigma=100, pose_prior_weight=4.78, + shape_prior_weight=5, angle_prior_weight=15.2, + output='sum'): + """ + Loss function for body fitting + """ + batch_size = body_pose.shape[0] + rotation = torch.eye(3, device=body_pose.device).unsqueeze(0).expand(batch_size, -1, -1) + + projected_joints = perspective_projection(model_joints, rotation, camera_t, + focal_length, camera_center) + + # Weighted robust reprojection error + reprojection_error = gmof(projected_joints - joints_2d, sigma) + reprojection_loss = (joints_conf ** 2) * reprojection_error.sum(dim=-1) + + # Pose prior loss + pose_prior_loss = (pose_prior_weight ** 2) * pose_prior(body_pose, betas) + + # Angle prior for knees and elbows + angle_prior_loss = (angle_prior_weight ** 2) * angle_prior(body_pose).sum(dim=-1) + + # Regularizer to prevent betas from taking large values + shape_prior_loss = (shape_prior_weight ** 2) * (betas ** 2).sum(dim=-1) + + total_loss = reprojection_loss.sum(dim=-1) + pose_prior_loss + angle_prior_loss + shape_prior_loss + + if output == 'sum': + return total_loss.sum() + elif output == 'reprojection': + return reprojection_loss + + +# --- get camera fitting loss ----- +def camera_fitting_loss(model_joints, camera_t, camera_t_est, camera_center, + joints_2d, joints_conf, + focal_length=5000, depth_loss_weight=100): + """ + Loss function for camera optimization. + """ + # Project model joints + batch_size = model_joints.shape[0] + rotation = torch.eye(3, device=model_joints.device).unsqueeze(0).expand(batch_size, -1, -1) + projected_joints = perspective_projection(model_joints, rotation, camera_t, + focal_length, camera_center) + + # get the indexed four + op_joints = ['OP RHip', 'OP LHip', 'OP RShoulder', 'OP LShoulder'] + op_joints_ind = [config.JOINT_MAP[joint] for joint in op_joints] + gt_joints = ['RHip', 'LHip', 'RShoulder', 'LShoulder'] + gt_joints_ind = [config.JOINT_MAP[joint] for joint in gt_joints] + + reprojection_error_op = (joints_2d[:, op_joints_ind] - + projected_joints[:, op_joints_ind]) ** 2 + reprojection_error_gt = (joints_2d[:, gt_joints_ind] - + projected_joints[:, gt_joints_ind]) ** 2 + + # Check if for each example in the batch all 4 OpenPose detections are valid, otherwise use the GT detections + # OpenPose joints are more reliable for this task, so we prefer to use them if possible + is_valid = (joints_conf[:, op_joints_ind].min(dim=-1)[0][:, None, None] > 0).float() + reprojection_loss = (is_valid * reprojection_error_op + (1 - is_valid) * reprojection_error_gt).sum(dim=(1, 2)) + + # Loss that penalizes deviation from depth estimate + depth_loss = (depth_loss_weight ** 2) * (camera_t[:, 2] - camera_t_est[:, 2]) ** 2 + + total_loss = reprojection_loss + depth_loss + return total_loss.sum() + + + + # #####--- body fitiing loss ----- +def body_fitting_loss_3d(body_pose, preserve_pose, + betas, model_joints, camera_translation, + j3d, pose_prior, + joints3d_conf, + sigma=100, pose_prior_weight=4.78*1.5, + shape_prior_weight=5.0, angle_prior_weight=15.2, + joint_loss_weight=500.0, + pose_preserve_weight=0.0, + use_collision=False, + model_vertices=None, model_faces=None, + search_tree=None, pen_distance=None, filter_faces=None, + collision_loss_weight=1000 + ): + """ + Loss function for body fitting + """ + batch_size = body_pose.shape[0] + + #joint3d_loss = (joint_loss_weight ** 2) * gmof((model_joints + camera_translation) - j3d, sigma).sum(dim=-1) + + joint3d_error = gmof((model_joints + camera_translation) - j3d, sigma) + + joint3d_loss_part = (joints3d_conf ** 2) * joint3d_error.sum(dim=-1) + joint3d_loss = ((joint_loss_weight ** 2) * joint3d_loss_part).sum(dim=-1) + + # Pose prior loss + pose_prior_loss = (pose_prior_weight ** 2) * pose_prior(body_pose, betas) + # Angle prior for knees and elbows + angle_prior_loss = (angle_prior_weight ** 2) * angle_prior(body_pose).sum(dim=-1) + # Regularizer to prevent betas from taking large values + shape_prior_loss = (shape_prior_weight ** 2) * (betas ** 2).sum(dim=-1) + + collision_loss = 0.0 + # Calculate the loss due to interpenetration + if use_collision: + triangles = torch.index_select( + model_vertices, 1, + model_faces).view(batch_size, -1, 3, 3) + + with torch.no_grad(): + collision_idxs = search_tree(triangles) + + # Remove unwanted collisions + if filter_faces is not None: + collision_idxs = filter_faces(collision_idxs) + + if collision_idxs.ge(0).sum().item() > 0: + collision_loss = torch.sum(collision_loss_weight * pen_distance(triangles, collision_idxs)) + + pose_preserve_loss = (pose_preserve_weight ** 2) * ((body_pose - preserve_pose) ** 2).sum(dim=-1) + + # print('joint3d_loss', joint3d_loss.shape) + # print('pose_prior_loss', pose_prior_loss.shape) + # print('angle_prior_loss', angle_prior_loss.shape) + # print('shape_prior_loss', shape_prior_loss.shape) + # print('collision_loss', collision_loss) + # print('pose_preserve_loss', pose_preserve_loss.shape) + + total_loss = joint3d_loss + pose_prior_loss + angle_prior_loss + shape_prior_loss + collision_loss + pose_preserve_loss + + return total_loss.sum() + + +# #####--- get camera fitting loss ----- +def camera_fitting_loss_3d(model_joints, camera_t, camera_t_est, + j3d, joints_category="orig", depth_loss_weight=100.0): + """ + Loss function for camera optimization. + """ + model_joints = model_joints + camera_t + # # get the indexed four + # op_joints = ['OP RHip', 'OP LHip', 'OP RShoulder', 'OP LShoulder'] + # op_joints_ind = [config.JOINT_MAP[joint] for joint in op_joints] + # + # j3d_error_loss = (j3d[:, op_joints_ind] - + # model_joints[:, op_joints_ind]) ** 2 + + gt_joints = ['RHip', 'LHip', 'RShoulder', 'LShoulder'] + gt_joints_ind = [config.JOINT_MAP[joint] for joint in gt_joints] + + if joints_category=="orig": + select_joints_ind = [config.JOINT_MAP[joint] for joint in gt_joints] + elif joints_category=="AMASS": + select_joints_ind = [config.AMASS_JOINT_MAP[joint] for joint in gt_joints] + else: + print("NO SUCH JOINTS CATEGORY!") + + j3d_error_loss = (j3d[:, select_joints_ind] - + model_joints[:, gt_joints_ind]) ** 2 + + # Loss that penalizes deviation from depth estimate + depth_loss = (depth_loss_weight**2) * (camera_t - camera_t_est)**2 + + total_loss = j3d_error_loss + depth_loss + return total_loss.sum() diff --git a/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/prior.py b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/prior.py new file mode 100755 index 0000000000000000000000000000000000000000..7f13806dd1f6607507b0c7e5ad463b3fb0026be8 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/prior.py @@ -0,0 +1,230 @@ +# -*- coding: utf-8 -*- + +# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is +# holder of all proprietary rights on this computer program. +# You can only use this computer program if you have closed +# a license agreement with MPG or you get the right to use the computer +# program from someone who is authorized to grant you that right. +# Any use of the computer program without a valid license is prohibited and +# liable to prosecution. +# +# Copyright©2019 Max-Planck-Gesellschaft zur Förderung +# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute +# for Intelligent Systems. All rights reserved. +# +# Contact: ps-license@tuebingen.mpg.de + +from __future__ import absolute_import +from __future__ import print_function +from __future__ import division + +import sys +import os + +import time +import pickle + +import numpy as np + +import torch +import torch.nn as nn + +DEFAULT_DTYPE = torch.float32 + + +def create_prior(prior_type, **kwargs): + if prior_type == 'gmm': + prior = MaxMixturePrior(**kwargs) + elif prior_type == 'l2': + return L2Prior(**kwargs) + elif prior_type == 'angle': + return SMPLifyAnglePrior(**kwargs) + elif prior_type == 'none' or prior_type is None: + # Don't use any pose prior + def no_prior(*args, **kwargs): + return 0.0 + prior = no_prior + else: + raise ValueError('Prior {}'.format(prior_type) + ' is not implemented') + return prior + + +class SMPLifyAnglePrior(nn.Module): + def __init__(self, dtype=torch.float32, **kwargs): + super(SMPLifyAnglePrior, self).__init__() + + # Indices for the roration angle of + # 55: left elbow, 90deg bend at -np.pi/2 + # 58: right elbow, 90deg bend at np.pi/2 + # 12: left knee, 90deg bend at np.pi/2 + # 15: right knee, 90deg bend at np.pi/2 + angle_prior_idxs = np.array([55, 58, 12, 15], dtype=np.int64) + angle_prior_idxs = torch.tensor(angle_prior_idxs, dtype=torch.long) + self.register_buffer('angle_prior_idxs', angle_prior_idxs) + + angle_prior_signs = np.array([1, -1, -1, -1], + dtype=np.float32 if dtype == torch.float32 + else np.float64) + angle_prior_signs = torch.tensor(angle_prior_signs, + dtype=dtype) + self.register_buffer('angle_prior_signs', angle_prior_signs) + + def forward(self, pose, with_global_pose=False): + ''' Returns the angle prior loss for the given pose + + Args: + pose: (Bx[23 + 1] * 3) torch tensor with the axis-angle + representation of the rotations of the joints of the SMPL model. + Kwargs: + with_global_pose: Whether the pose vector also contains the global + orientation of the SMPL model. If not then the indices must be + corrected. + Returns: + A sze (B) tensor containing the angle prior loss for each element + in the batch. + ''' + angle_prior_idxs = self.angle_prior_idxs - (not with_global_pose) * 3 + return torch.exp(pose[:, angle_prior_idxs] * + self.angle_prior_signs).pow(2) + + +class L2Prior(nn.Module): + def __init__(self, dtype=DEFAULT_DTYPE, reduction='sum', **kwargs): + super(L2Prior, self).__init__() + + def forward(self, module_input, *args): + return torch.sum(module_input.pow(2)) + + +class MaxMixturePrior(nn.Module): + + def __init__(self, prior_folder='prior', + num_gaussians=6, dtype=DEFAULT_DTYPE, epsilon=1e-16, + use_merged=True, + **kwargs): + super(MaxMixturePrior, self).__init__() + + if dtype == DEFAULT_DTYPE: + np_dtype = np.float32 + elif dtype == torch.float64: + np_dtype = np.float64 + else: + print('Unknown float type {}, exiting!'.format(dtype)) + sys.exit(-1) + + self.num_gaussians = num_gaussians + self.epsilon = epsilon + self.use_merged = use_merged + gmm_fn = 'gmm_{:02d}.pkl'.format(num_gaussians) + + full_gmm_fn = os.path.join(prior_folder, gmm_fn) + if not os.path.exists(full_gmm_fn): + print('The path to the mixture prior "{}"'.format(full_gmm_fn) + + ' does not exist, exiting!') + sys.exit(-1) + + with open(full_gmm_fn, 'rb') as f: + gmm = pickle.load(f, encoding='latin1') + + if type(gmm) == dict: + means = gmm['means'].astype(np_dtype) + covs = gmm['covars'].astype(np_dtype) + weights = gmm['weights'].astype(np_dtype) + elif 'sklearn.mixture.gmm.GMM' in str(type(gmm)): + means = gmm.means_.astype(np_dtype) + covs = gmm.covars_.astype(np_dtype) + weights = gmm.weights_.astype(np_dtype) + else: + print('Unknown type for the prior: {}, exiting!'.format(type(gmm))) + sys.exit(-1) + + self.register_buffer('means', torch.tensor(means, dtype=dtype)) + + self.register_buffer('covs', torch.tensor(covs, dtype=dtype)) + + precisions = [np.linalg.inv(cov) for cov in covs] + precisions = np.stack(precisions).astype(np_dtype) + + self.register_buffer('precisions', + torch.tensor(precisions, dtype=dtype)) + + # The constant term: + sqrdets = np.array([(np.sqrt(np.linalg.det(c))) + for c in gmm['covars']]) + const = (2 * np.pi)**(69 / 2.) + + nll_weights = np.asarray(gmm['weights'] / (const * + (sqrdets / sqrdets.min()))) + nll_weights = torch.tensor(nll_weights, dtype=dtype).unsqueeze(dim=0) + self.register_buffer('nll_weights', nll_weights) + + weights = torch.tensor(gmm['weights'], dtype=dtype).unsqueeze(dim=0) + self.register_buffer('weights', weights) + + self.register_buffer('pi_term', + torch.log(torch.tensor(2 * np.pi, dtype=dtype))) + + cov_dets = [np.log(np.linalg.det(cov.astype(np_dtype)) + epsilon) + for cov in covs] + self.register_buffer('cov_dets', + torch.tensor(cov_dets, dtype=dtype)) + + # The dimensionality of the random variable + self.random_var_dim = self.means.shape[1] + + def get_mean(self): + ''' Returns the mean of the mixture ''' + mean_pose = torch.matmul(self.weights, self.means) + return mean_pose + + def merged_log_likelihood(self, pose, betas): + diff_from_mean = pose.unsqueeze(dim=1) - self.means + + prec_diff_prod = torch.einsum('mij,bmj->bmi', + [self.precisions, diff_from_mean]) + diff_prec_quadratic = (prec_diff_prod * diff_from_mean).sum(dim=-1) + + curr_loglikelihood = 0.5 * diff_prec_quadratic - \ + torch.log(self.nll_weights) + # curr_loglikelihood = 0.5 * (self.cov_dets.unsqueeze(dim=0) + + # self.random_var_dim * self.pi_term + + # diff_prec_quadratic + # ) - torch.log(self.weights) + + min_likelihood, _ = torch.min(curr_loglikelihood, dim=1) + return min_likelihood + + def log_likelihood(self, pose, betas, *args, **kwargs): + ''' Create graph operation for negative log-likelihood calculation + ''' + likelihoods = [] + + for idx in range(self.num_gaussians): + mean = self.means[idx] + prec = self.precisions[idx] + cov = self.covs[idx] + diff_from_mean = pose - mean + + curr_loglikelihood = torch.einsum('bj,ji->bi', + [diff_from_mean, prec]) + curr_loglikelihood = torch.einsum('bi,bi->b', + [curr_loglikelihood, + diff_from_mean]) + cov_term = torch.log(torch.det(cov) + self.epsilon) + curr_loglikelihood += 0.5 * (cov_term + + self.random_var_dim * + self.pi_term) + likelihoods.append(curr_loglikelihood) + + log_likelihoods = torch.stack(likelihoods, dim=1) + min_idx = torch.argmin(log_likelihoods, dim=1) + weight_component = self.nll_weights[:, min_idx] + weight_component = -torch.log(weight_component) + + return weight_component + log_likelihoods[:, min_idx] + + def forward(self, pose, betas): + if self.use_merged: + return self.merged_log_likelihood(pose, betas) + else: + return self.log_likelihood(pose, betas) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/smplify.py b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/smplify.py new file mode 100755 index 0000000000000000000000000000000000000000..be32870e48b177b46cf91655ebf2592a379fe843 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/joints2smpl/src/smplify.py @@ -0,0 +1,281 @@ +from __future__ import absolute_import + +import torch +import os, sys +import pickle +import smplx +import numpy as np + +sys.path.append(os.path.dirname(__file__)) +from customloss import (camera_fitting_loss, + body_fitting_loss, + camera_fitting_loss_3d, + body_fitting_loss_3d, + ) +from prior import MaxMixturePrior +from mmcm.t2p.visualize.joints2smpl.src import config + + + +@torch.no_grad() +def guess_init_3d(model_joints, + j3d, + joints_category="orig"): + """Initialize the camera translation via triangle similarity, by using the torso joints . + :param model_joints: SMPL model with pre joints + :param j3d: 25x3 array of Kinect Joints + :returns: 3D vector corresponding to the estimated camera translation + """ + # get the indexed four + gt_joints = ['RHip', 'LHip', 'RShoulder', 'LShoulder'] + gt_joints_ind = [config.JOINT_MAP[joint] for joint in gt_joints] + + if joints_category=="orig": + joints_ind_category = [config.JOINT_MAP[joint] for joint in gt_joints] + elif joints_category=="AMASS": + joints_ind_category = [config.AMASS_JOINT_MAP[joint] for joint in gt_joints] + else: + print("NO SUCH JOINTS CATEGORY!") + + sum_init_t = (j3d[:, joints_ind_category] - model_joints[:, gt_joints_ind]).sum(dim=1) + init_t = sum_init_t / 4.0 + return init_t + + +# SMPLIfy 3D +class SMPLify3D(): + """Implementation of SMPLify, use 3D joints.""" + + def __init__(self, + smplxmodel, + step_size=1e-2, + batch_size=1, + num_iters=100, + use_collision=False, + use_lbfgs=True, + joints_category="orig", + device=torch.device('cuda:0'), + ): + + # Store options + self.batch_size = batch_size + self.device = device + self.step_size = step_size + + self.num_iters = num_iters + # --- choose optimizer + self.use_lbfgs = use_lbfgs + # GMM pose prior + self.pose_prior = MaxMixturePrior(prior_folder=config.GMM_MODEL_DIR, + num_gaussians=8, + dtype=torch.float32).to(device) + # collision part + self.use_collision = use_collision + if self.use_collision: + self.part_segm_fn = config.Part_Seg_DIR + + # reLoad SMPL-X model + self.smpl = smplxmodel + + self.model_faces = smplxmodel.faces_tensor.view(-1) + + # select joint joint_category + self.joints_category = joints_category + + if joints_category=="orig": + self.smpl_index = config.full_smpl_idx + self.corr_index = config.full_smpl_idx + elif joints_category=="AMASS": + self.smpl_index = config.amass_smpl_idx + self.corr_index = config.amass_idx + else: + self.smpl_index = None + self.corr_index = None + print("NO SUCH JOINTS CATEGORY!") + + # ---- get the man function here ------ + def __call__(self, init_pose, init_betas, init_cam_t, j3d, conf_3d=1.0, seq_ind=0): + """Perform body fitting. + Input: + init_pose: SMPL pose estimate + init_betas: SMPL betas estimate + init_cam_t: Camera translation estimate + j3d: joints 3d aka keypoints + conf_3d: confidence for 3d joints + seq_ind: index of the sequence + Returns: + vertices: Vertices of optimized shape + joints: 3D joints of optimized shape + pose: SMPL pose parameters of optimized shape + betas: SMPL beta parameters of optimized shape + camera_translation: Camera translation + """ + + # # # add the mesh inter-section to avoid + search_tree = None + pen_distance = None + filter_faces = None + + if self.use_collision: + from mesh_intersection.bvh_search_tree import BVH + import mesh_intersection.loss as collisions_loss + from mesh_intersection.filter_faces import FilterFaces + + search_tree = BVH(max_collisions=8) + + pen_distance = collisions_loss.DistanceFieldPenetrationLoss( + sigma=0.5, point2plane=False, vectorized=True, penalize_outside=True) + + if self.part_segm_fn: + # Read the part segmentation + part_segm_fn = os.path.expandvars(self.part_segm_fn) + with open(part_segm_fn, 'rb') as faces_parents_file: + face_segm_data = pickle.load(faces_parents_file, encoding='latin1') + faces_segm = face_segm_data['segm'] + faces_parents = face_segm_data['parents'] + # Create the module used to filter invalid collision pairs + filter_faces = FilterFaces( + faces_segm=faces_segm, faces_parents=faces_parents, + ign_part_pairs=None).to(device=self.device) + + + # Split SMPL pose to body pose and global orientation + body_pose = init_pose[:, 3:].detach().clone() + global_orient = init_pose[:, :3].detach().clone() + betas = init_betas.detach().clone() + + # use guess 3d to get the initial + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas) + model_joints = smpl_output.joints + + init_cam_t = guess_init_3d(model_joints, j3d, self.joints_category).unsqueeze(1).detach() + camera_translation = init_cam_t.clone() + + preserve_pose = init_pose[:, 3:].detach().clone() + # -------------Step 1: Optimize camera translation and body orientation-------- + # Optimize only camera translation and body orientation + body_pose.requires_grad = False + betas.requires_grad = False + global_orient.requires_grad = True + camera_translation.requires_grad = True + + camera_opt_params = [global_orient, camera_translation] + + if self.use_lbfgs: + camera_optimizer = torch.optim.LBFGS(camera_opt_params, max_iter=self.num_iters, + lr=self.step_size, line_search_fn='strong_wolfe') + for i in range(10): + def closure(): + camera_optimizer.zero_grad() + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas) + model_joints = smpl_output.joints + # print('model_joints', model_joints.shape) + # print('camera_translation', camera_translation.shape) + # print('init_cam_t', init_cam_t.shape) + # print('j3d', j3d.shape) + loss = camera_fitting_loss_3d(model_joints, camera_translation, + init_cam_t, j3d, self.joints_category) + loss.backward() + return loss + + camera_optimizer.step(closure) + else: + camera_optimizer = torch.optim.Adam(camera_opt_params, lr=self.step_size, betas=(0.9, 0.999)) + + for i in range(20): + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas) + model_joints = smpl_output.joints + + loss = camera_fitting_loss_3d(model_joints[:, self.smpl_index], camera_translation, + init_cam_t, j3d[:, self.corr_index], self.joints_category) + camera_optimizer.zero_grad() + loss.backward() + camera_optimizer.step() + + # Fix camera translation after optimizing camera + # --------Step 2: Optimize body joints -------------------------- + # Optimize only the body pose and global orientation of the body + body_pose.requires_grad = True + global_orient.requires_grad = True + camera_translation.requires_grad = True + + # --- if we use the sequence, fix the shape + if seq_ind == 0: + betas.requires_grad = True + body_opt_params = [body_pose, betas, global_orient, camera_translation] + else: + betas.requires_grad = False + body_opt_params = [body_pose, global_orient, camera_translation] + + if self.use_lbfgs: + body_optimizer = torch.optim.LBFGS(body_opt_params, max_iter=self.num_iters, + lr=self.step_size, line_search_fn='strong_wolfe') + for i in range(self.num_iters): + def closure(): + body_optimizer.zero_grad() + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas) + model_joints = smpl_output.joints + model_vertices = smpl_output.vertices + + loss = body_fitting_loss_3d(body_pose, preserve_pose, betas, model_joints[:, self.smpl_index], camera_translation, + j3d[:, self.corr_index], self.pose_prior, + joints3d_conf=conf_3d, + joint_loss_weight=600.0, + pose_preserve_weight=5.0, + use_collision=self.use_collision, + model_vertices=model_vertices, model_faces=self.model_faces, + search_tree=search_tree, pen_distance=pen_distance, filter_faces=filter_faces) + loss.backward() + return loss + + body_optimizer.step(closure) + else: + body_optimizer = torch.optim.Adam(body_opt_params, lr=self.step_size, betas=(0.9, 0.999)) + + for i in range(self.num_iters): + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas) + model_joints = smpl_output.joints + model_vertices = smpl_output.vertices + + loss = body_fitting_loss_3d(body_pose, preserve_pose, betas, model_joints[:, self.smpl_index], camera_translation, + j3d[:, self.corr_index], self.pose_prior, + joints3d_conf=conf_3d, + joint_loss_weight=600.0, + use_collision=self.use_collision, + model_vertices=model_vertices, model_faces=self.model_faces, + search_tree=search_tree, pen_distance=pen_distance, filter_faces=filter_faces) + body_optimizer.zero_grad() + loss.backward() + body_optimizer.step() + + # Get final loss value + with torch.no_grad(): + smpl_output = self.smpl(global_orient=global_orient, + body_pose=body_pose, + betas=betas, return_full_pose=True) + model_joints = smpl_output.joints + model_vertices = smpl_output.vertices + + final_loss = body_fitting_loss_3d(body_pose, preserve_pose, betas, model_joints[:, self.smpl_index], camera_translation, + j3d[:, self.corr_index], self.pose_prior, + joints3d_conf=conf_3d, + joint_loss_weight=600.0, + use_collision=self.use_collision, model_vertices=model_vertices, model_faces=self.model_faces, + search_tree=search_tree, pen_distance=pen_distance, filter_faces=filter_faces) + + vertices = smpl_output.vertices.detach() + joints = smpl_output.joints.detach() + pose = torch.cat([global_orient, body_pose], dim=-1).detach() + betas = betas.detach() + + return vertices, joints, pose, betas, camera_translation, final_loss diff --git a/MuseV/MMCM/mmcm/t2p/visualize/render_mesh.py b/MuseV/MMCM/mmcm/t2p/visualize/render_mesh.py new file mode 100755 index 0000000000000000000000000000000000000000..5899ba96562dc465626be66e3e661e8d7c1fecca --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/render_mesh.py @@ -0,0 +1,33 @@ +import argparse +import os +from .visualize import vis_utils +import shutil +from tqdm import tqdm + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("--input_path", type=str, required=True, help='stick figure mp4 file to be rendered.') + parser.add_argument("--cuda", type=bool, default=True, help='') + parser.add_argument("--device", type=int, default=0, help='') + params = parser.parse_args() + + assert params.input_path.endswith('.mp4') + parsed_name = os.path.basename(params.input_path).replace('.mp4', '').replace('sample', '').replace('rep', '') + sample_i, rep_i = [int(e) for e in parsed_name.split('_')] + npy_path = os.path.join(os.path.dirname(params.input_path), 'results.npy') + out_npy_path = params.input_path.replace('.mp4', '_smpl_params.npy') + assert os.path.exists(npy_path) + results_dir = params.input_path.replace('.mp4', '_obj') + if os.path.exists(results_dir): + shutil.rmtree(results_dir) + os.makedirs(results_dir) + + npy2obj = vis_utils.npy2obj(npy_path, sample_i, rep_i, + device=params.device, cuda=params.cuda) + + print('Saving obj files to [{}]'.format(os.path.abspath(results_dir))) + for frame_i in tqdm(range(npy2obj.real_num_frames)): + npy2obj.save_obj(os.path.join(results_dir, 'frame{:03d}.obj'.format(frame_i)), frame_i) + + print('Saving SMPL params to [{}]'.format(os.path.abspath(out_npy_path))) + npy2obj.save_npy(out_npy_path) diff --git a/MuseV/MMCM/mmcm/t2p/visualize/simplify_loc2rot.py b/MuseV/MMCM/mmcm/t2p/visualize/simplify_loc2rot.py new file mode 100755 index 0000000000000000000000000000000000000000..2c7fae0b3fe2f1b0b19fc51e6a2983f8fd9cb530 --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/simplify_loc2rot.py @@ -0,0 +1,131 @@ +import numpy as np +import os +import torch +from ..visualize.joints2smpl.src import config +import smplx +import h5py +from ..visualize.joints2smpl.src.smplify import SMPLify3D +from tqdm import tqdm +from ..utils import rotation_conversions as geometry +import argparse + + +class joints2smpl: + + def __init__(self, num_frames, device_id, cuda=True): + self.device = torch.device("cuda:" + str(device_id) if cuda else "cpu") + # self.device = torch.device("cpu") + self.batch_size = num_frames + self.num_joints = 22 # for HumanML3D + self.joint_category = "AMASS" + self.num_smplify_iters = 150 + self.fix_foot = False + print(config.SMPL_MODEL_DIR) + smplmodel = smplx.create(config.SMPL_MODEL_DIR, + model_type="smpl", gender="neutral", ext="pkl", + batch_size=self.batch_size).to(self.device) + + # ## --- load the mean pose as original ---- + smpl_mean_file = config.SMPL_MEAN_FILE + + file = h5py.File(smpl_mean_file, 'r') + self.init_mean_pose = torch.from_numpy(file['pose'][:]).unsqueeze(0).repeat(self.batch_size, 1).float().to(self.device) + self.init_mean_shape = torch.from_numpy(file['shape'][:]).unsqueeze(0).repeat(self.batch_size, 1).float().to(self.device) + self.cam_trans_zero = torch.Tensor([0.0, 0.0, 0.0]).unsqueeze(0).to(self.device) + # + + # # #-------------initialize SMPLify + self.smplify = SMPLify3D(smplxmodel=smplmodel, + batch_size=self.batch_size, + joints_category=self.joint_category, + num_iters=self.num_smplify_iters, + device=self.device) + + + def npy2smpl(self, npy_path): + out_path = npy_path.replace('.npy', '_rot.npy') + motions = np.load(npy_path, allow_pickle=True)[None][0] + # print_batch('', motions) + n_samples = motions['motion'].shape[0] + all_thetas = [] + for sample_i in tqdm(range(n_samples)): + thetas, _ = self.joint2smpl(motions['motion'][sample_i].transpose(2, 0, 1)) # [nframes, njoints, 3] + all_thetas.append(thetas.cpu().numpy()) + motions['motion'] = np.concatenate(all_thetas, axis=0) + print('motions', motions['motion'].shape) + + print(f'Saving [{out_path}]') + np.save(out_path, motions) + exit() + + + + def joint2smpl(self, input_joints, init_params=None): + _smplify = self.smplify # if init_params is None else self.smplify_fast + pred_pose = torch.zeros(self.batch_size, 72).to(self.device) + pred_betas = torch.zeros(self.batch_size, 10).to(self.device) + pred_cam_t = torch.zeros(self.batch_size, 3).to(self.device) + keypoints_3d = torch.zeros(self.batch_size, self.num_joints, 3).to(self.device) + + # run the whole seqs + num_seqs = input_joints.shape[0] + + + # joints3d = input_joints[idx] # *1.2 #scale problem [check first] + keypoints_3d = torch.Tensor(input_joints).to(self.device).float() + + # if idx == 0: + if init_params is None: + pred_betas = self.init_mean_shape + pred_pose = self.init_mean_pose + pred_cam_t = self.cam_trans_zero + else: + pred_betas = init_params['betas'] + pred_pose = init_params['pose'] + pred_cam_t = init_params['cam'] + + if self.joint_category == "AMASS": + confidence_input = torch.ones(self.num_joints) + # make sure the foot and ankle + if self.fix_foot == True: + confidence_input[7] = 1.5 + confidence_input[8] = 1.5 + confidence_input[10] = 1.5 + confidence_input[11] = 1.5 + else: + print("Such category not settle down!") + + new_opt_vertices, new_opt_joints, new_opt_pose, new_opt_betas, \ + new_opt_cam_t, new_opt_joint_loss = _smplify( + pred_pose.detach(), + pred_betas.detach(), + pred_cam_t.detach(), + keypoints_3d, + conf_3d=confidence_input.to(self.device), + # seq_ind=idx + ) + + thetas = new_opt_pose.reshape(self.batch_size, 24, 3) + thetas = geometry.matrix_to_rotation_6d(geometry.axis_angle_to_matrix(thetas)) # [bs, 24, 6] + root_loc = torch.tensor(keypoints_3d[:, 0]) # [bs, 3] + root_loc = torch.cat([root_loc, torch.zeros_like(root_loc)], dim=-1).unsqueeze(1) # [bs, 1, 6] + thetas = torch.cat([thetas, root_loc], dim=1).unsqueeze(0).permute(0, 2, 3, 1) # [1, 25, 6, 196] + + return thetas.clone().detach(), {'pose': new_opt_joints[0, :24].flatten().clone().detach(), 'betas': new_opt_betas.clone().detach(), 'cam': new_opt_cam_t.clone().detach()} + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument("--input_path", type=str, required=True, help='Blender file or dir with blender files') + parser.add_argument("--cuda", type=bool, default=True, help='') + parser.add_argument("--device", type=int, default=0, help='') + params = parser.parse_args() + + simplify = joints2smpl(device_id=params.device, cuda=params.cuda) + + if os.path.isfile(params.input_path) and params.input_path.endswith('.npy'): + simplify.npy2smpl(params.input_path) + elif os.path.isdir(params.input_path): + files = [os.path.join(params.input_path, f) for f in os.listdir(params.input_path) if f.endswith('.npy')] + for f in files: + simplify.npy2smpl(f) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/t2p/visualize/vis_utils.py b/MuseV/MMCM/mmcm/t2p/visualize/vis_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..7fd996437b24c4a93725260c61676005167ee54a --- /dev/null +++ b/MuseV/MMCM/mmcm/t2p/visualize/vis_utils.py @@ -0,0 +1,66 @@ +from ..model.rotation2xyz import Rotation2xyz +import numpy as np +from trimesh import Trimesh +import os +import torch +from .visualize.simplify_loc2rot import joints2smpl + +class npy2obj: + def __init__(self, npy_path, sample_idx, rep_idx, device=0, cuda=True): + self.npy_path = npy_path + self.motions = np.load(self.npy_path, allow_pickle=True) + if self.npy_path.endswith('.npz'): + self.motions = self.motions['arr_0'] + self.motions = self.motions[None][0] + self.rot2xyz = Rotation2xyz(device='cpu') + self.faces = self.rot2xyz.smpl_model.faces + self.bs, self.njoints, self.nfeats, self.nframes = self.motions['motion'].shape + self.opt_cache = {} + self.sample_idx = sample_idx + self.total_num_samples = self.motions['num_samples'] + self.rep_idx = rep_idx + self.absl_idx = self.rep_idx*self.total_num_samples + self.sample_idx + self.num_frames = self.motions['motion'][self.absl_idx].shape[-1] + self.j2s = joints2smpl(num_frames=self.num_frames, device_id=device, cuda=cuda) + + if self.nfeats == 3: + print(f'Running SMPLify For sample [{sample_idx}], repetition [{rep_idx}], it may take a few minutes.') + motion_tensor, opt_dict = self.j2s.joint2smpl(self.motions['motion'][self.absl_idx].transpose(2, 0, 1)) # [nframes, njoints, 3] + self.motions['motion'] = motion_tensor.cpu().numpy() + elif self.nfeats == 6: + self.motions['motion'] = self.motions['motion'][[self.absl_idx]] + self.bs, self.njoints, self.nfeats, self.nframes = self.motions['motion'].shape + self.real_num_frames = self.motions['lengths'][self.absl_idx] + + self.vertices = self.rot2xyz(torch.tensor(self.motions['motion']), mask=None, + pose_rep='rot6d', translation=True, glob=True, + jointstype='vertices', + # jointstype='smpl', # for joint locations + vertstrans=True) + self.root_loc = self.motions['motion'][:, -1, :3, :].reshape(1, 1, 3, -1) + self.vertices += self.root_loc + + def get_vertices(self, sample_i, frame_i): + return self.vertices[sample_i, :, :, frame_i].squeeze().tolist() + + def get_trimesh(self, sample_i, frame_i): + return Trimesh(vertices=self.get_vertices(sample_i, frame_i), + faces=self.faces) + + def save_obj(self, save_path, frame_i): + mesh = self.get_trimesh(0, frame_i) + with open(save_path, 'w') as fw: + mesh.export(fw, 'obj') + return save_path + + def save_npy(self, save_path): + data_dict = { + 'motion': self.motions['motion'][0, :, :, :self.real_num_frames], + 'thetas': self.motions['motion'][0, :-1, :, :self.real_num_frames], + 'root_translation': self.motions['motion'][0, -1, :3, :self.real_num_frames], + 'faces': self.faces, + 'vertices': self.vertices[0, :, :, :self.real_num_frames], + 'text': self.motions['text'][0], + 'length': self.real_num_frames, + } + np.save(save_path, data_dict) diff --git a/MuseV/MMCM/mmcm/text/__init__.py b/MuseV/MMCM/mmcm/text/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/text/feature_extractor/__init__.py b/MuseV/MMCM/mmcm/text/feature_extractor/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/text/feature_extractor/clip_text_extractor.py b/MuseV/MMCM/mmcm/text/feature_extractor/clip_text_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..80faa344f2b26389d07ffd7f6717bbff5c41aeee --- /dev/null +++ b/MuseV/MMCM/mmcm/text/feature_extractor/clip_text_extractor.py @@ -0,0 +1,98 @@ +import sys +from multiprocessing.pool import Pool +import os +import logging +from typing import Union, List, Tuple + +import torch +import numpy as np +import pandas as pd +import h5py +import diffusers +from diffusers import AutoencoderKL +from diffusers.image_processor import VaeImageProcessor +from einops import rearrange +from PIL import Image +from transformers import CLIPTextModel, CLIPTokenizer + +from ...data.extract_feature.base_extract_feature import BaseFeatureExtractor + +from .save_text_emb import save_text_emb_with_h5py + + +class ClipTextFeatureExtractor(BaseFeatureExtractor): + def __init__( + self, + pretrained_model_name_or_path: str, + device: str = "cpu", + dtype: torch.dtype = None, + name: str = "CLIPEncoderLayer", + ): + super().__init__(device, dtype, name) + self.pretrained_model_name_or_path = pretrained_model_name_or_path + self.tokenizer = CLIPTokenizer.from_pretrained( + pretrained_model_name_or_path, subfolder="tokenizer" + ) + text_encoder = CLIPTextModel.from_pretrained( + pretrained_model_name_or_path, subfolder="text_encoder" + ) + text_encoder.requires_grad_(False) + self.text_encoder = text_encoder.to(device=device, dtype=dtype) + + def extract( + self, + text: Union[str, List[str]], + return_type: str = "numpy", + save_emb_path: str = None, + save_type: str = "h5py", + text_emb_key: str = None, + text_key: str = "text", + text_tuple_length: int = 20, + text_index: int = 0, + insert_name_to_key: bool = False, + ) -> Union[np.ndarray, torch.Tensor]: + if text_emb_key is not None: + text_emb_key = f"{text_emb_key}_{text_index}" + if self.name is not None and insert_name_to_key: + if text_emb_key is not None: + text_emb_key = f"{self.name}_{text_emb_key}" + text_inputs = self.tokenizer( + text, + max_length=self.tokenizer.model_max_length, + padding="max_length", + truncation=True, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + if ( + hasattr(self.text_encoder.config, "use_attention_mask") + and self.text_encoder.config.use_attention_mask + ): + attention_mask = text_inputs.attention_mask.to(self.device) + else: + attention_mask = None + # transformers.modeling_outputs.BaseModelOutputWithPooling + # 'last_hidden_state', 'pooler_output' + # we choose the first + print() + text_embeds = self.text_encoder( + text_input_ids.to(device=self.device), + attention_mask=attention_mask, + )[0] + + if return_type == "numpy": + text_embeds = text_embeds.cpu().numpy() + if save_emb_path is None: + return text_embeds + else: + if save_type == "h5py": + save_text_emb_with_h5py( + path=save_emb_path, + emb=text_embeds, + text_emb_key=text_emb_key, + text=text, + text_key=text_key, + text_tuple_length=text_tuple_length, + text_index=text_index, + ) + return text_embeds diff --git a/MuseV/MMCM/mmcm/text/feature_extractor/save_text_emb.py b/MuseV/MMCM/mmcm/text/feature_extractor/save_text_emb.py new file mode 100755 index 0000000000000000000000000000000000000000..e85e82be9ccffb5e75dd6572a3e08c8315fc39ac --- /dev/null +++ b/MuseV/MMCM/mmcm/text/feature_extractor/save_text_emb.py @@ -0,0 +1,28 @@ +from typing import Union + +import h5py +import numpy as np + +from ...data.emb.h5py_emb import save_value_with_h5py + + +def save_text_emb_with_h5py( + path: str, + emb: Union[np.ndarray, None] = None, + text_emb_key: str = None, + text: str = None, + text_key: str = "text", + text_tuple_length: int = 20, + text_index: int = 0, +) -> None: + if emb is not None: + save_value_with_h5py(path, value=emb, key=text_emb_key) + if text is not None: + save_value_with_h5py( + path, + key=text_key, + value=text, + shape=(text_tuple_length,), + dtype=h5py.string_dtype(encoding="utf-8"), + idx=text_index, + ) diff --git a/MuseV/MMCM/mmcm/text/taiyi/__init__.py b/MuseV/MMCM/mmcm/text/taiyi/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/text/taiyi/taiyi_predictor.py b/MuseV/MMCM/mmcm/text/taiyi/taiyi_predictor.py new file mode 100755 index 0000000000000000000000000000000000000000..b4ea0c3026727c375d3001e21a89ac41b8e1794f --- /dev/null +++ b/MuseV/MMCM/mmcm/text/taiyi/taiyi_predictor.py @@ -0,0 +1,46 @@ +from typing import List, Tuple, Dict +import os +import time + +from tqdm import tqdm +import torch +import numpy as np +from numpy import ndarray +from PIL import Image +from transformers import BertForSequenceClassification, BertTokenizer, CLIPProcessor, CLIPModel + + + +class TextFeatureExtractor(object): + def __init__(self, language_model_path: str, local_file: bool=True, device: str='cpu'): + if device: + self.device = device + else: + self.device = 'cuda' if torch.cuda.is_available() else 'cpu' + language_model_path = "Taiyi-CLIP-Roberta-large-326M-Chinese" if local_file else "IDEA-CCNL/Taiyi-CLIP-Roberta-large-326M-Chinese" + self.text_tokenizer = BertTokenizer.from_pretrained(language_model_path, local_files_only=local_file) + self.text_encoder = BertForSequenceClassification.from_pretrained(language_model_path, local_files_only=local_file).eval().to(self.device) + + def text(self, query_texts: List[str]) -> ndarray: + text = self.text_tokenizer(query_texts, return_tensors='pt', padding=True, truncation=True, max_length=self.text_encoder.config.max_length)['input_ids'] + text = text.to(self.device) + with torch.no_grad(): + text_features = self.text_encoder(text).logits + text_features = text_features / text_features.norm(dim=1, keepdim=True) + text_features = text_features.squeeze + return text_features.detach().cpu().numpy() + + +class TaiyiFeatureExtractor(TextFeatureExtractor): + def __init__(self, language_model_path: str="Taiyi-CLIP-Roberta-large-326M-Chinese", local_file: bool = True, device: str = 'cpu'): + """_summary_ + + Args: + language_model_path (str, optional): Taiyi-CLIP-Roberta-large-326M-Chinese or IDEA-CCNL/Taiyi-CLIP-Roberta-large-326M-Chinese. Defaults to "Taiyi-CLIP-Roberta-large-326M-Chinese". + local_file (bool, optional): _description_. Defaults to True. + device (str, optional): _description_. Defaults to 'cpu'. + """ + super().__init__(language_model_path, local_file, device) + + + diff --git a/MuseV/MMCM/mmcm/text/utils/__init__.py b/MuseV/MMCM/mmcm/text/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/text/utils/read_text.py b/MuseV/MMCM/mmcm/text/utils/read_text.py new file mode 100644 index 0000000000000000000000000000000000000000..a3134a15a927a4b1568352e85647f1a7db9cf5fa --- /dev/null +++ b/MuseV/MMCM/mmcm/text/utils/read_text.py @@ -0,0 +1,17 @@ +# -*- coding: UTF-8 -*- + +""" +__author__ = zhiqiangxia +__date__ = 2020-04-15 +""" + +import xml.etree.ElementTree as ET +import xmltodict + + +def read_xml2json(path): + tree = ET.parse(path) + root = tree.getroot() + xmlstr = ET.tostring(root).decode() + dct = xmltodict.parse(xml_input=xmlstr) + return dct diff --git a/MuseV/MMCM/mmcm/utils/__init__.py b/MuseV/MMCM/mmcm/utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..bd76a6fdd1195c2d83f4c80d2fa55818cc0ca6f4 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: UTF-8 -*- +from .util import load_dct_from_file \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/utils/color_util.py b/MuseV/MMCM/mmcm/utils/color_util.py new file mode 100755 index 0000000000000000000000000000000000000000..9fd29147000735b2507428766618ac37c625dd39 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/color_util.py @@ -0,0 +1,18 @@ +from typing import List, Union, Tuple + +class PolledColor(object): + def __init__(self, colors: Union[List[Tuple[int, int, int]], List[Tuple[str, str, str]]]) -> None: + """轮流返回候选颜色列表中的颜色 + + Args: + colors (list): 候选颜色列表 + """ + self.colors = colors + self.cnt = 0 + self.n_color = len(colors) + + @property + def color(self) -> Union[Tuple[int, int, int], Tuple[str, str, str]]: + color = self.colors[self.cnt % self.n_color] + self.cnt += 1 + return color diff --git a/MuseV/MMCM/mmcm/utils/compute_util.py b/MuseV/MMCM/mmcm/utils/compute_util.py new file mode 100755 index 0000000000000000000000000000000000000000..63528e635c5f25de34eef6db139ed189916c2aa7 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/compute_util.py @@ -0,0 +1,19 @@ +from typing import List +import numpy as np + + +def weighted_sum(weights: List[float], datas: List[np.array]) -> np.array: + """对矩阵列表按照权重列表加权求和 + + Args: + weights (list): 权重列表 + datas (list): 矩阵列表 + + Returns: + np.array: 加权求和后的矩阵 + """ + res = np.zeros(datas[0].shape) + n_data = len(datas) + for i in range(n_data): + res += datas[i] * weights[i] / n_data + return res diff --git a/MuseV/MMCM/mmcm/utils/data_util.py b/MuseV/MMCM/mmcm/utils/data_util.py new file mode 100755 index 0000000000000000000000000000000000000000..7c3914a9959d59c1fb0c690bc828e54f2efe31ef --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/data_util.py @@ -0,0 +1,85 @@ +from typing import List, Dict, Sequence, Union, Tuple, Any, Hashable + +import numpy as np + + +def pick_subdct(src: Dict[Hashable, Any], target_keys: List[str] = None, ignored_keys: List[str] = None) -> Dict[Hashable, Any]: + """提取字典中的目标子字典 + + Args: + src (Dict[Hashable, Any]): 原字典 + target_keys (List[str], optional): 目标key. Defaults to None. + ignored_keys (List[str], optional): 忽略的key. Defaults to None. + + Returns: + Dict[Hashable, Any]: 子字典 + """ + dst = {} + if target_keys is not None: + for k in target_keys: + if k in src: + dst[k] = src[k] + if ignored_keys is not None: + for k in src: + if k not in ignored_keys: + dst[k] = src[k] + return dst + + +def str2intlist(string: str, sep: str="_", range_sep: str=":", discrete_sep=",") -> List[int]: + """将1:2_3:4_5,6,7的字符串转化成整数索引列表，方便取子任务, 左闭右比 + + Args: + string (str): 输入字符串 + + Returns: + List: 转化后的整数列表 + """ + string = string.split(sep) + lst = [] + for s in string: + if range_sep in s: + # 采用左闭、右闭方式 + start, end = [int(x) for x in s.split(range_sep)] + sub_lst = range(start, end + 1) + else: + sub_lst = [int(x) for x in s.split(discrete_sep)] + lst.extend(sub_lst) + lst = sorted(set(lst)) + return lst + + +def dict_has_keys(dct: Dict[Hashable, Any], keys: List[Union[str, int]]) -> bool: + """嵌套字典是否有嵌套key + + Args: + dct (Dict[Hashable, Any]): 有多层嵌套的字典 + keys (List[Union[str, int]]): 字符串列表，从前往后表示嵌套字典key + + Returns: + bool: dct是否有keys + """ + if keys[0] not in dct: + # if not hasattr(dct, keys[0]): + return False + else: + if len(keys) == 1: + return True + else: + return dict_has_keys(dct[keys[0]], keys[1:]) + + +def dict_get_keys(dct: Dict[Hashable, Any], keys: List[Union[str, int]]) -> Any: + """根据索引列表获取嵌套字典的值 + + Args: + dct (Dict[Hashable, Any]): 嵌套字典 + keys (List[Union[str, int]]): 用列表表示的嵌套索引 + + Returns: + Any: 嵌套索引keys对应的值 + """ + if len(keys) == 1: + return dct[keys[0]] + else: + return dict_get_keys(dct[keys[0]], keys[1:]) diff --git a/MuseV/MMCM/mmcm/utils/gpu_util.py b/MuseV/MMCM/mmcm/utils/gpu_util.py new file mode 100755 index 0000000000000000000000000000000000000000..dfacf60890d0fd2c7f1d1d97b2c7dddb4f455cce --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/gpu_util.py @@ -0,0 +1,95 @@ +from typing import Union, List, Dict, Tuple, Literal + +import logging + + +def convert_byte_unit( + value: float, + src_unit: Literal["b", "B", "KB", "MB", "GB", "TB"], + target_unit: Literal["b", "B", "KB", "MB", "GB", "TB"], +) -> float: + """convert value in src_unit to target_unit. Firstlt, all src_unit to Byte, then to target_unit + + Args: + value (float): _description_ + src_unit (Literal["b", "B", "KB", "MB", "GB", "TB"]): _description_ + target_unit (Literal["b", "B", "KB", "MB", "GB", "TB"]): _description_ + + Raises: + ValueError: _description_ + ValueError: _description_ + + Returns: + float: _description_ + """ + if src_unit in ["b", "bit"]: + value = value / 8 + elif src_unit in ["B", "Byte"]: + pass + elif src_unit == "KB": + value = value * 1024 + elif src_unit == "MB": + value = value * 1024**2 + elif src_unit == "GB": + value = value * (1024**3) + elif src_unit == "TB": + value = value * (1024**4) + else: + raise ValueError("src_unit is not valid") + if target_unit in ["b", "bit"]: + target_value = value * 8 + elif target_unit in ["B", "Byte"]: + target_value = value + elif target_unit == "KB": + target_value = value / 1024 + elif target_unit == "MB": + target_value = value / 1024**2 + elif target_unit == "GB": + target_value = value / (1024**3) + elif target_unit == "TB": + target_value = value / (1024**4) + else: + raise ValueError("target_unit is not valid") + return target_value + + +def get_gpu_status(unit="MB") -> List[Dict]: + import pynvml + + try: + infos = [] + + # 初始化 pynvml + pynvml.nvmlInit() + # 获取 GPU 数量 + deviceCount = pynvml.nvmlDeviceGetCount() + + # 获取每个 GPU 的信息 + for i in range(deviceCount): + gpu_info = {} + handle = pynvml.nvmlDeviceGetHandleByIndex(i) + info = pynvml.nvmlDeviceGetMemoryInfo(handle) + utilization = pynvml.nvmlDeviceGetUtilizationRates(handle) + gpu_name = pynvml.nvmlDeviceGetName(handle) + gpu_info = { + "gpu_name": gpu_name, + "total_memory": convert_byte_unit( + info.total, src_unit="B", target_unit=unit + ), + "used_memory": convert_byte_unit( + info.used, src_unit="B", target_unit=unit + ), + "used_memory_ratio": info.used / info.total, + "gpu_utilization": utilization.gpu, + "free_memory_ratio": info.free / info.total, + "free_memory": convert_byte_unit( + info.free, src_unit="B", target_unit=unit + ), + } + infos.append(gpu_info) + # 释放 pynvml + pynvml.nvmlShutdown() + except Exception as e: + print("get_gpu_status failed") + logging.exception(e) + return infos diff --git a/MuseV/MMCM/mmcm/utils/itertools_util.py b/MuseV/MMCM/mmcm/utils/itertools_util.py new file mode 100755 index 0000000000000000000000000000000000000000..37c580d3bc485473d8bc6a9628c74bdd072116bc --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/itertools_util.py @@ -0,0 +1,91 @@ +from typing import Any, List, Union, Sequence, Tuple + +import numpy as np + + +def generate_sample_idxs( + total: int, + window_size: int, + step: int, + sample_rate: int = 1, + drop_last: bool = False, + max_num_per_window: int = None, +) -> List[List[int]]: + """generate sample idxs list by given relate parameters + + Args: + total (int): total num of sampling source + window_size (int): + step (int): _description_ + sample_rate (int, optional): _description_. Defaults to 1. + drop_last (bool, optional): wthether drop the last, if not enough for window_size. Defaults to False. + + Returns: + List[List[int]]: sample idx list + """ + idxs = range(total) + idxs = [idx for i, idx in enumerate(idxs) if i % sample_rate == 0] + sample_idxs = [] + new_total = len(idxs) + last_idx = new_total - 1 + window_start = 0 + while window_start < new_total: + window_end = window_start + window_size + window = idxs[window_start:window_end] + if max_num_per_window is not None and len(window) > max_num_per_window: + window = uniform_sample_subseq( + window, max_num=max_num_per_window, need_index=False + ) + if window_end > new_total and drop_last: + break + else: + sample_idxs.append(window) + window_start += step + return sample_idxs + + +def overlap2step(overlap: Union[int, float], window_size: int) -> int: + if isinstance(overlap, int): + step = window_size - overlap + elif isinstance(overlap, float): + if overlap <= 0: + raise ValueError(f"relative overlap should be > 0, but given{overlap}") + overlap = int(overlap * window_size) + else: + raise ValueError( + f"overlap only support int(>0） or float(>0), but given {overlap} type({type(overlap)})" + ) + return step + + +def step2overlap(step: int, window_size: int) -> int: + overlap = window_size - step + return overlap + + +def uniform_sample_subseq( + seq: Sequence, max_num: int, need_index: bool = False +) -> Union[Sequence, Tuple[Sequence, Sequence]]: + n_seq = len(seq) + sample_num = min(n_seq, max_num) + if n_seq <= max_num: + if need_index: + return seq, list(range(n_seq)) + else: + return seq + idx = sorted(list(set(np.linspace(0, n_seq - 1, dtype=int)))) + subseq = [seq[i] for i in idx] + if need_index: + return subseq, idx + else: + return subseq + + +def convert_list_flat2nest( + seq: Sequence, + window: int, +) -> List[List[Any]]: + n_seq = len(seq) + n_lst = n_seq // window + int(n_seq % window > 0) + res = [seq[i * window : (i + 1) * window] for i in range(n_lst)] + return res diff --git a/MuseV/MMCM/mmcm/utils/load_util.py b/MuseV/MMCM/mmcm/utils/load_util.py new file mode 100644 index 0000000000000000000000000000000000000000..7fe6a655adeb11f2fc2b4b715d748c3863b96eb1 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/load_util.py @@ -0,0 +1,34 @@ +import json +import yaml +import importlib + + +def load_dct_from_file(path, obj_name=None): + if path.endswith(".json"): + dct = load_json(path) + elif path.endswith(".yaml"): + dct = load_yaml(path) + elif path.endswith(".py"): + dct = load_edct_py(path, obj_name) + else: + raise ValueError("unsupported config file") + return dct + + +def load_json(path): + with open(path, "r") as f: + dct = json.load(f) + return dct + + +def load_yaml(path): + dct = yaml.load(path) + return dct + + +def load_pyhon_obj(path, obj_name): + module_name = "module_name" + spec = importlib.util.spec_from_file_location(module_name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return getattr(module, obj_name) diff --git a/MuseV/MMCM/mmcm/utils/path_util.py b/MuseV/MMCM/mmcm/utils/path_util.py new file mode 100755 index 0000000000000000000000000000000000000000..bbccf9fba49d8d331be2995039e4d748430cccd7 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/path_util.py @@ -0,0 +1,69 @@ +import os +from typing import Tuple, Callable, Dict +from functools import partial + + +def get_file_name_ext(basename: str) -> Tuple[str, str]: + """分离文件名和后缀，适用于复杂命名的分离，目前支持 + 含.的名字 + + Args: + basename (str): xx.xxx.xx.ext + + Returns: + Tuple[str, str]: name, ext + """ + ext = basename.split(".")[-1] + name = ".".join(basename.split(".")[:-1]) + return name, ext + + +def get_dir_file_map( + path, split_func=None, filter_func: Callable = None, exts: list = None +) -> dict: + """遍历目标文件夹及子文件夹下所有符合后缀目标的文件，生成字典。 + split_func 可以用于对文件名做处理生成想要的字典key。 + + Args: + path (str): 目标文件夹 + split_func (__call__, optional): 可以用于对文件名做处理生成想要的字典key。. Defaults to None. + exts (list, optional): 目标文件后缀, 例如["mp3", "json"]. Defaults to None. + + Returns: + dict: key是处理后的文件名，值是绝对路径 + """ + dct = {} + for rootdir, dirnames, basenames in os.walk(path): + for basename in basenames: + path = os.path.join(rootdir, basename) + if filter_func is not None: + if not filter_func(path): + continue + if split_func is None: + ext = basename.split(".")[-1] + filename = ".".join(basename.split(".")[:-1]) + else: + filename, ext = split_func(basename) + if exts is None: + dct[filename] = path + else: + if ext.lower() in exts: + dct[filename] = path + return dct + + +def get_path_dct(path, exts, mode: int=1, split_func: Callable=None, sep: str="@") -> Dict[str, str]: + """遍历目标文件夹及子文件夹下所有视频文件，生成字典。""" + if mode == 1: + dct = get_dir_file_map(path, exts=exts) + elif mode == 2: + dct = get_dir_file_map(path, split_func=split_func, exts=exts) + elif mode== 3: + dct = get_path_dct(path, mode=1, sep=sep, exts=exts) + dct2 = get_path_dct(path, mode=2, sep=sep, split_func=split_func, exts=exts) + dct.update(**dct2) + else: + raise ValueError("only support mode 1, 2, 3") + return dct + + diff --git a/MuseV/MMCM/mmcm/utils/process_util.py b/MuseV/MMCM/mmcm/utils/process_util.py new file mode 100755 index 0000000000000000000000000000000000000000..5dd189f22aa8ebfd522b7c79e62f812d5951926b --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/process_util.py @@ -0,0 +1,97 @@ +from multiprocessing import Pool, Process, Value, Lock, Pool +from threading import Thread +from multiprocessing.pool import ThreadPool +from typing import List, Callable, Any, Tuple +import multiprocessing as mp + + +from functools import partial + + +def run_task_in_parallel( + worker: Callable, + tasks: List[Any], + num: int = 1, + process_type: str = "process", + use_counter: bool = False, + print_freq: int = 100, +) -> Tuple[List, None]: + """并行运行任务的设置 + + Args: + worker (func): 工作函数 + tasks (iterator): 任务队列 + num (int, optional): 并行处理核数量. Defaults to 1. + process_type (str, optional): 并行处理类型，process or thread. Defaults to "process". + use_counter (bool, optional): 是否使用全局计数器. Defaults to False. + print_freq (int, optional): 打印计算进展. Defaults to 100.q + """ + results = [] + n_task = len(tasks) + if num == 1: + for i, task in enumerate(tasks): + result = worker(task) + results.append(result) + if use_counter: + if i % print_freq == 0: + print(f"finished {n_task}/{i} tasks") + else: + if use_counter: + raise NotImplementedError( + "not supported counter for multiprocess/multithread" + ) + process_cls = Pool if process_type == "process" else ThreadPool + with process_cls(num) as p: + results = p.map(worker, tasks) + return results + + +def prepare_task(tasks, queue, lock): + for i, task in enumerate(tasks): + with lock: + if i % 100 == 0: + # if i % 1 == 0: + print("prepare task: ", i, task) + queue.put(task) + + +def worker_task(worker, queue, lock, counter): + while True: + with lock: + task = queue.get() + counter.value += 1 + print("finish task: ", counter.value, task) + if task is None: + break + worker.do_task(task) + + +def run_pipeline(worker_class, tasks, n_process=4): + # lock = mp.Lock() + # 用不上却会影响死锁？ + manager = mp.Manager() + # lock = manager.Lock() + # queue = manager.Queue() + # counter = manager.Value("i", 0) + lock = mp.Lock() + queue = mp.Queue() + counter = mp.Value("i", 0) + prepare_process = mp.Process(target=prepare_task, args=(tasks, queue, lock)) + prepare_process.start() + worker_processes = [] + for i in range(n_process): # number of worker processes + worker = worker_class() + worker_process = mp.Process( + target=worker_task, args=(worker, queue, lock, counter) + ) + worker_process.start() + worker_processes.append(worker_process) + + prepare_process.join() + # queue.join() + + for i in range(n_process): # number of worker processes + queue.put(None) + + for worker_process in worker_processes: + worker_process.join() diff --git a/MuseV/MMCM/mmcm/utils/rainbow_util.py b/MuseV/MMCM/mmcm/utils/rainbow_util.py new file mode 100755 index 0000000000000000000000000000000000000000..0dc685693fa59e15f4037ce3e4278a4f9da07f1f --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/rainbow_util.py @@ -0,0 +1,18 @@ +# -*- coding: utf8 -*- +from typing import Any + + +def load_rainbow_config( + app_id: str, user_id: str, secret_key: str, group: str, env_name: str = "Default" +) -> Any: + from rainbow_sdk.rainbow_client import RainbowClient + + init_param = { + "connectStr": "api.rainbow.oa.com:8080", + "isUsingFileCache": False, + "fileCachePath": "/data/rainbow/", + "tokenConfig": {"app_id": app_id, "user_id": user_id, "secret_key": secret_key}, + } + rc = RainbowClient(init_param) + res = rc.get_configs_v3(group, env_name=env_name) + return res["data"] diff --git a/MuseV/MMCM/mmcm/utils/register.py b/MuseV/MMCM/mmcm/utils/register.py new file mode 100755 index 0000000000000000000000000000000000000000..101f332c49a4d22e84d7b87dc9f7565a96fb2ee1 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/register.py @@ -0,0 +1,46 @@ +from typing import Any, List + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class Register: + def __init__(self, registry_name: str): + self._dict = {} + self._name = registry_name + + def __setitem__(self, key: str, value: Any) -> None: + if not callable(value): + raise Exception(f"Value of a Registry must be a callable!\nValue: {value}") + # 优先使用自定义的name，其次使用类名或者函数名。 + if "name" in value.__dict__: + key = value.name + elif key is None: + key = value.__name__ + if key in self._dict: + logger.warning("Key %s already in registry %s." % (key, self._name)) + self._dict[key] = value + + def register(self, target: str) -> Any: + """Decorator to register a function or class.""" + + def add(key, value): + self[key] = value + return value + + if callable(target): + # @reg.register + return add(None, target) + # @reg.register('alias') + return lambda x: add(target, x) + + def __getitem__(self, key: str) -> Any: + return self._dict[key] + + def __contains__(self, key: str) -> bool: + return key in self._dict + + def keys(self) -> List[str]: + """key""" + return self._dict.keys() diff --git a/MuseV/MMCM/mmcm/utils/seed_util.py b/MuseV/MMCM/mmcm/utils/seed_util.py new file mode 100644 index 0000000000000000000000000000000000000000..0954fd88ac9555a18b898ed56c54c2036f0bf768 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/seed_util.py @@ -0,0 +1,16 @@ +from typing import Tuple +import os, random + +import numpy as np +import torch + + +def set_all_seed(seed: int) -> Tuple[torch.Generator, torch.Generator]: + random.seed(seed) + os.environ["PYTHONHASHSEED"] = str(seed) + np.random.seed(seed) + cpu_generator = torch.Generator("cpu").manual_seed(seed) + gpu_generator = torch.Generator("cuda").manual_seed(seed) + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = True + return cpu_generator, gpu_generator diff --git a/MuseV/MMCM/mmcm/utils/signature.py b/MuseV/MMCM/mmcm/utils/signature.py new file mode 100755 index 0000000000000000000000000000000000000000..21b0ae5092144e7443b7559f38be6ee1b4839e77 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/signature.py @@ -0,0 +1,66 @@ +from typing import Union, List + +import hashlib +import os + + +def get_md5sum(data: str, length: int = None, blocksize: int=2**23) -> str: + """获取文件的hash值前几位作为文件唯一标识符 + + Args: + path (str): 文件路径 + length (int, optional): hash前多少位. Defaults to None. + blocksize (int, optional):分块读取，块的大小. Defaults to None. + + Returns: + str: hash值前length位 + """ + if isinstance(data, str): + if os.path.isfile(data): + signature = get_md5sum_of_file(path=data, length=length, blocksize=blocksize) + else: + signature = get_signature_of_string(data, length=length) + else: + raise ValueError( + "only support str or file path str, but given {}".format(type(data)) + ) + return signature + + +def get_md5sum_of_file(path: str, length: int = None, blocksize: int=2**23) -> str: + """获取文件的hash值前几位作为文件唯一标识符 + + Args: + path (str): 文件路径 + length (int, optional): hash前多少位. Defaults to None. + blocksize (int, optional):分块读取，块的大小. Defaults to None. + + Returns: + str: hash值前length位 + """ + + # sig = (os.popen('md5sum {}'.format(path))).readlines()[0].split(' ')[0] + m = hashlib.md5() + with open(path, "rb") as f: + while chunk := f.read(blocksize): + m.update(chunk) + sig = m.hexdigest() + if length is not None: + sig = sig[:length] + return sig + + +def get_signature_of_string(string: str, length: int = None) -> str: + """cal signature of string + + Args: + string (str): target string + length (int, optional): only return the first length character of signature. Defaults to None. + + Returns: + str: signature of string + """ + sig = hashlib.md5(string.encode()).hexdigest() + if length is not None: + sig = sig[:length] + return sig diff --git a/MuseV/MMCM/mmcm/utils/str_util.py b/MuseV/MMCM/mmcm/utils/str_util.py new file mode 100755 index 0000000000000000000000000000000000000000..4fe3ff7849e26766f55b20ffd8b1b703ddaf2b1a --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/str_util.py @@ -0,0 +1,53 @@ +from typing import List + +import re + + +def has_key_brace(string: str) -> bool: + """检测字符串中是否含有{x}。 + 注意，不是检测是否有{} + + Args: + string (str): + + Returns: + bool: + """ + flag = re.search("\{.+\}", string) + flag = flag is not None + return flag + + +def merge_near_same_char(string: str, target_char=", ") -> str: + """合并连续不变的指定字符为1个。如 `1,2,,3,,,4`合并成`1,2,3` + + Args: + string (str): 待处理的字符串 + target_char (str, optional): 指定的连续字符. Defaults to ",". + + Returns: + str: 处理后的字符串 + """ + string = re.sub("({}*)+".format(target_char), target_char, string) + return string + + +def get_word_from_key_brace_string(string: str, start="{", end="}") -> List: + """从含有`{key}`的模板字符串中 获取所有的关键词`key` + + Args: + string (str): 含有`{key}`的模板字符串 + + Returns: + List: 所有关键词 key 列表 + """ + words = re.findall(f"{start}[^{start}|^{end}]+{end}", string) + words = [word[len(start) : -len(end)] for word in words] + return words + + +def clean_str_for_save(string: str, disallowed_chars: List = None): + if disallowed_chars is None: + disallowed_chars = r'[\\/:*?"<>|]' + cleaned_filename = re.sub(disallowed_chars, "", string) + return cleaned_filename diff --git a/MuseV/MMCM/mmcm/utils/table_util.py b/MuseV/MMCM/mmcm/utils/table_util.py new file mode 100755 index 0000000000000000000000000000000000000000..cf2c2f48b466d40692afd4dc3e2b4ee5c589687a --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/table_util.py @@ -0,0 +1,239 @@ +import io +from typing import List, Dict, Tuple, BinaryIO +from copy import deepcopy + +import pandas as pd +from PIL import Image +from xlsxwriter.utility import xl_col_to_name + +def read_image_data(path: str, target_image_height: int) -> Tuple[BinaryIO, int, int]: + """读取图像，按照目标高做resize处理，并转化成二进制格式，返回最终图像的宽和高 + + Args: + path (str): 图像路径 + target_image_height (int): 目标高 + + Returns: + Tuple[BinaryIO, int, int]: 图像二进制格式，返回最终图像的宽和高 + """ + image = Image.open(path) + image_width_in_excel = int(image.width / (image.height / target_image_height)) + image = image.resize(size=(image_width_in_excel, target_image_height)) + image_byte = io.BytesIO() + image.save(image_byte, format="png") + return image_byte, image.width, image.height + + +def set_text_column_dynamic_width(worksheet, df, format, default_width=50): + """将df在excel workshhet中的列按照实际内容长度设置列宽以及文本格式 + + Args: + worksheet (_type_): 待处理的excel worksheet + df (_type_): worksheet中原来对应的DataFrame格式 + format (_type_): 对应列的文本格式 + default_width (int, optional): 默认目标宽度. Defaults to 50. + """ + for column in df: + column_width = max(df[column].astype(str).map(len).max(), len(column)) + col_idx = df.columns.get_loc(column) + width = min(column_width, default_width) + worksheet.set_column(col_idx, col_idx, width, format) + + +def convert_tasks2clean(tasks): + tasks = [{"prompt": task["prompt"]} for task in tasks] + return tasks + + +def split_tasks_by_images_lst(tasks, save_images_path_key: str = "save_images_path"): + new_tasks = [] + for task in tasks: + for image_path in task[save_images_path_key]: + new_task = deepcopy(task) + new_task[save_images_path_key] = image_path + new_tasks.append(new_task) + return new_tasks + + +def save_texts_images_2_csv(tasks: List[Dict], save_path: str): + """存储相关结果为csv表格 + + tasks (List[Dict]): 待转换的字典列表 + save_path (str): 表格存储路径 + """ + df = pd.DataFrame(tasks) + df.to_csv(save_path, encoding="utf_8_sig", index=False) + + +def add_multi_data_validation(workbook, worksheet, validates, validate_idxs, n_rows): + for i, validate in enumerate(validates): + validate_idx = validate_idxs[i] + worksheet = add_data_validation( + workbook=workbook, + worksheet=worksheet, + col=validate_idx, + head=validate["col_name"], + candidates=validate["candidates"], + colors=validate["colors"], + n_rows=n_rows, + ) + return worksheet + + +def add_data_validation( + workbook, worksheet, col: int, head, candidates, n_rows, colors +): + col = xl_col_to_name(col) + # Adding the header and Datavalidation list + worksheet.write('{}1'.format(col), head) + colors_fmt = [workbook.add_format({'bg_color': color}) for color in colors] + for row in range(n_rows): + cell_idx = '{}{}'.format(col, row + 2) + worksheet.data_validation(cell_idx, {'validate': 'list', 'source': candidates}) + for i_c in range(len(candidates)): + worksheet.conditional_format( + cell_idx, + { + 'type': 'formula', + 'criteria': '=${}=\"{}\"'.format(cell_idx, candidates[i_c]), + 'format': colors_fmt[i_c], + }, + ) + return worksheet + + +def insert_cell_image( + worksheet, + row, + col, + image_path, + image_height_in_table, + text_format, + row_ratio, + col_ratio, +): + image_byte, new_image_width, new_image_height = read_image_data( + image_path, target_image_height=image_height_in_table + ) + # TODO：现在的图像列并不是预期内的和图像等宽，而是宽了很多 + worksheet.set_column( + col, + col, + int(new_image_width / col_ratio), + ) + worksheet.insert_image( + row, + col, + image_path, + {"image_data": image_byte}, + ) + worksheet.set_row(row, int(new_image_height / row_ratio), text_format) + return worksheet + + +def save_texts_images_2_excel( + tasks: List[Dict], + save_path: str, + image_height_in_table: int = 120, + row_ratio: float = 1.3, + col_ratio: float = 5, + validates: List = None, +): + """将任务列表和生成的图像统一存储在表格中，方便观看对比实验结果。 + + Args: + tasks (List[Dict]): 待转换的字典列表 + save_path (str): 表格存储路径 + image_height_in_table (int, optional): 表格中缩略图的高. Defaults to 120. + row_ratio (float, optional): excel的单元格宽高和实际图像边长需要做比例转换. Defaults to 1.2. + col_ratio (float, optional): excel的单元格宽高和实际图像边长需要做比例转换. Defaults to 7.5. + need_add_checker_column (bool, optional): 是否新增一列用于审核检查状态. Defaults to False. + """ + df = pd.DataFrame(tasks) + # 先找到需要插入图像的列，插入图像列 + keys_with_image = [ + k for k in tasks[0].keys() if "images_path" in k and k != "save_images_path" + ] + high_priority_col_idx = 0 + # 默认save_images_path是生成图像，放在后面 + if "save_images_path" in tasks[0]: + keys_with_image.append("save_images_path") + for img_key in keys_with_image: + maxlen_img_key_value = max( + [ + len(task[img_key]) if isinstance(task[img_key], list) else 1 + for task in tasks + ] + ) + for i in range(maxlen_img_key_value): + column = "{}_{}".format(img_key, i) + if column not in df.columns: + df.insert( + loc=high_priority_col_idx, + column=column, + value="", + ) + high_priority_col_idx += 1 + + validate_start_idx = high_priority_col_idx + if validates is not None: + for i, validate in enumerate(validates): + if validate["col_name"] not in df.columns: + col_idx = validate_start_idx + i + df.insert(loc=col_idx, column=validate["col_name"], value="") + validate_idxs = range(validate_start_idx, validate_start_idx + len(validates)) + writer = pd.ExcelWriter(save_path, engine="xlsxwriter") + # Convert the dataframe to an XlsxWriter Excel object. + df.to_excel(writer, sheet_name="Sheet1", index=False) + # Get the xlsxwriter workbook and worksheet objects. + workbook = writer.book + worksheet = writer.sheets["Sheet1"] + n_col = len(df.columns) + n_row = len(df) + text_format = workbook.add_format({"text_wrap": True}) + set_text_column_dynamic_width(worksheet=worksheet, df=df, format=text_format) + # Insert an image. + for row in range(len(df)): + task = tasks[row] + cell_col = 0 + for im_idx, img_key in enumerate(keys_with_image): + images_path = task[img_key] + if not isinstance(images_path, list): + cell_row = 1 + row + worksheet.write(cell_row, cell_col, img_key) + if len(images_path) == 0: + continue + worksheet = insert_cell_image( + worksheet=worksheet, + row=cell_row, + col=cell_col, + image_path=images_path, + image_height_in_table=image_height_in_table, + text_format=text_format, + row_ratio=row_ratio, + col_ratio=col_ratio, + ) + cell_col += 1 + else: + for i, image_path in enumerate(images_path): + worksheet = insert_cell_image( + worksheet=worksheet, + row=cell_row, + col=cell_col, + image_path=image_path, + image_height_in_table=image_height_in_table, + text_format=text_format, + row_ratio=row_ratio, + col_ratio=col_ratio, + ) + cell_col += 1 + if validates is not None: + worksheet = add_multi_data_validation( + workbook, + worksheet, + validates=validates, + validate_idxs=validate_idxs, + n_rows=len(df), + ) + # Close the Pandas Excel writer and output the Excel file. + writer.save() diff --git a/MuseV/MMCM/mmcm/utils/task_util.py b/MuseV/MMCM/mmcm/utils/task_util.py new file mode 100755 index 0000000000000000000000000000000000000000..8c5ac02acee1f9a3f508ae0ffe0a0e91b31d679c --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/task_util.py @@ -0,0 +1,102 @@ +from copy import deepcopy +from itertools import product +import os +from typing import Dict, List +import logging + +import pandas as pd + +from .path_util import get_dir_file_map +from .signature import get_signature_of_string + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def generate_tasks( + path: str, + key: str = None, + sep: str = ",", + exts: List[str] = None, + subset_row: str = None, +) -> List[Dict]: + """读取文件，生成任务表格 + + Args: + path (str): 任务文件路径 + key (str, optional): 作为任务名的字段. Defaults to None. + sep (str, optional): 表格字段分隔符. Defaults to ",". + exts (List[str], optional): 如果是文件夹，目前文件类型. Defaults to None. + subset_row (str, optional): 将1:2_3:4的字符串转化成整数索引列表，方便取子任务. Defaults to None. + + Returns: + List[Dict]: 列表后的任务字典列表 + """ + if os.path.isdir(path): + tasks = get_dir_file_map(path=path, exts=exts) + tasks = [{key: k, path: v} for k, v in tasks.items()] + else: + ext = os.path.splitext(os.path.basename(path))[0] + if ext == "csv": + tasks = pd.read_csv(path, sep=sep) + if subset_row is not None: + subset_row = read_subset_rows(subset_row) + tasks = tasks.iloc[subset_row] + tasks = tasks.to_dict(orient="records") + else: + tasks = [{key: path}] + return tasks + + +def get_filename_from_str(string, n=100, has_signature=True, n_signature=8): + name = string[:n] + if has_signature: + signature = get_signature_of_string(string, n_signature) + name = "{}_{}".format(name, signature) + return name + + +def read_subset_rows(string: str) -> List: + """将1:2_3:4的字符串转化成整数索引列表，方便取子任务 + + Args: + string (str): _description_ + + Returns: + List: _description_ + """ + string = string.split("_") + lst = [] + for s in string: + if ":" in s: + # 采用左闭、右闭方式 + start, end = [int(x) for x in s.split(":")] + sub_lst = range(start, end + 1) + else: + sub_lst = [int(x) for x in s.split(",")] + lst.extend(sub_lst) + lst = sorted(set(lst)) + return lst + + +def fiss_tasks(tasks: List[Dict], task_fission_sep: str = "|") -> List[Dict]: + """fiss tasks if task_fission_sep in value by product""" + new_tasks = [] + for task in tasks: + combination_fields = [ + k for k, v in task.items() if isinstance(v, str) and task_fission_sep in v + ] + if len(combination_fields) == 0: + new_tasks.append(task) + continue + product_fields = [ + task[field].split(task_fission_sep) for field in combination_fields + ] + product_fields = list(product(*product_fields)) + # print("combination_fields", combination_fields) + # print("product_fields", product_fields) + for values in product_fields: + task_cp = deepcopy(task) + for i, field in enumerate(combination_fields): + task_cp[field] = values[i] + new_tasks.append(task_cp) + return new_tasks diff --git a/MuseV/MMCM/mmcm/utils/time_util.py b/MuseV/MMCM/mmcm/utils/time_util.py new file mode 100755 index 0000000000000000000000000000000000000000..ce8a4bdc012a3e9965828ad835d94c66f4e8d84a --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/time_util.py @@ -0,0 +1,38 @@ +import time + + +def get_current_strtime(fmt: str = "%Y-%m-%d %H:%M:%S") -> str: + """get_current_strtime + + Args: + fmt (_type_, optional): str time format. Defaults to "%Y-%m-%d %H:%M:%S". + + Returns: + str: timestr + """ + current_time = time.strftime(fmt, time.localtime()) + return current_time + + +def timestr_2_seconds(timestr: str) -> float: + """convert timestr to time float num, + + Args: + timestr (str): should be h:m:s or h:m:s:M or h:m:s.M + + Returns: + float: seconds + """ + timestr_lst = timestr.split(":") + if len(timestr_lst) == 1: + seconds = float(timestr_lst[0]) + else: + if len(timestr_lst) == 3: + time_range = [3600, 60, 1] + elif len(timestr_lst) == 4: + time_range = [3600, 60, 1, 1e-3] + timestr_lst[-1] = timestr_lst[-1][:3] + else: + raise ValueError("timestr should be like h:m:s or h:m:s:M or h:m:s.M, but given {}".format(timestr)) + seconds = sum([float(timestr_lst[i]) * time_range[i] for i in range(len(timestr_lst))]) + return round(seconds, 3) diff --git a/MuseV/MMCM/mmcm/utils/transfer_util.py b/MuseV/MMCM/mmcm/utils/transfer_util.py new file mode 100755 index 0000000000000000000000000000000000000000..d9d3c582e7f903f8d2515af73b26d441329a2d54 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/transfer_util.py @@ -0,0 +1,43 @@ +import os + +from typing import Callable + + +def download_data(src: str, dst: str = None, download_func: Callable = None) -> str: + """使用download_func将目标文件下载到目标路径下 + + Args: + src (str): _description_ + dst (str, optional): _description_. Defaults to None. + download_func (Callable, optional): _description_. Defaults to None. + + Returns: + str: _description_ + """ + if not os.path.exists(dst): + download_func(src, dst) + return dst + + +def download_data_with_cos(src: str, dst: str) -> None: + """使用cos工具下载cos上的文件 + + Args: + src (str): 原目录， + dst (str): 目标目录，暂不支持修改后的目录名字 + """ + from cos_utils.crate import CosCrate + + src_basename = os.path.basename(src) + dst_path = os.path.join(dst, src_basename) + if os.path.exists(dst_path): + print("existed: {}".format(dst_path)) + return + if "." not in src_basename: + if src[-1] != "/": + src += "/" + if "." not in os.path.basename(dst): + if dst[-1] != "/": + dst += "/" + CosCrate().download_to_local(src, dst) + \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/utils/util.py b/MuseV/MMCM/mmcm/utils/util.py new file mode 100755 index 0000000000000000000000000000000000000000..5287c597bb1434442252b03fc58a5a09c20e5ce6 --- /dev/null +++ b/MuseV/MMCM/mmcm/utils/util.py @@ -0,0 +1,309 @@ +# -*- coding: UTF-8 -*- + +""" +__author__ = zhiqiangxia +__date__ = 2019-03-18 +""" + +import os +import time +import json +import importlib.util +from typing import Any, Tuple, Dict, List, Iterable +from collections import Counter +import pandas as pd + +import yaml +import pandas as pd + + +def dict2list(dct: dict) -> list: + """将字典转换为列表，若值为列表，使用extend而不是append + + Args: + dct (dict): + + Returns: + list: + """ + lst = [] + for k, v in dct.items(): + if isinstance(v, list): + lst.extend(v) + else: + lst.append(v) + return lst + + +class Timer(object): + """A simple timer.""" + + def __init__(self): + self.total_time = 0.0 + self.calls = 0 + self.start_time = 0.0 + self.diff = 0.0 + self.average_time = 0.0 + + def tic(self) -> float: + # using time.time instead of time.clock because time time.clock + # does not normalize for multithreading + self.start_time = time.time() + + def toc(self, average: bool = True) -> float: + self.diff = time.time() - self.start_time + self.total_time += self.diff + self.calls += 1 + self.average_time = self.total_time / self.calls + if average: + return self.average_time + else: + return self.diff + + +def load_dct_from_file(path: str, key=None) -> dict: + """读取字典类型的文件 + + Args: + path (str): 字典文件路径 + + Raises: + ValueError: 不支持该字典文件类型，仅支持json、yaml、python中的字典key + + Returns: + dict: 读取的字典 + """ + if path.endswith(".json"): + dct = load_json(path) + elif path.endswith(".yaml"): + dct = load_yaml(path) + elif path.endswith(".py"): + dct = load_edct_py(path, key) + else: + raise ValueError("unsupported config file") + return dct + + +def load_json(path: str) -> dict: + """读取json文件 + + Args: + path (str): json路径 + + Returns: + dict: 读取后的python 字典 + """ + with open(path, "r", encoding="utf-8") as f: + dct = json.load(f) + return dct + + +def load_yaml(path: str) -> dict: + """读取yaml文件 + + Args: + path (str): yaml路径 + + Returns: + dict: 读取后的python 字典 + """ + dct = yaml.load(path) + return dct + + +def load_edct_py(path: str, obj_name: str = None) -> dict: + """读取Python中的字典 + + Args: + path (str): py文件路径 + obj_name (str): py文件中的字典变量名 + + Returns: + dict: 读取后的字典 + """ + module_name = "module_name" + spec = importlib.util.spec_from_file_location(module_name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + dct = module if obj_name is None else getattr(module, obj_name) + return dct + + +def merge_dct(target_dct: dict, source_dct: dict = None) -> None: + """ + merge source_dct into target_dct + """ + if source_dct is not None: + for k, v in source_dct.items(): + if k not in target_dct: + target_dct[k] = v + else: + if not isinstance(v, dict): + target_dct[k] = v + else: + merge_dct(target_dct[k], source_dct[k]) + + +def convert_class_attr_to_dict( + obj: object, target_keys: list = None, ignored_keys: list = None +) -> dict: + """将类中的属性转化成字典，默认转化为所有属性。 + + Args: + obj (object): 类对象 + target_keys (list, optional): 需要保存的属性. Defaults to None. + ignored_keys (list, optional): 需要忽视的属性. Defaults to None. + + Returns: + dict: 转换后的字典 + """ + if target_keys is not None: + dct = {k: v for k, v in obj.__dict__.items() if k in target_keys} + return dct + if ignored_keys is None: + ignored_keys = [] + dct = {k: v for k, v in obj.__dict__.items() if k not in ignored_keys} + return dct + + +def merge_list_continuous_same_element(lst: List[Any]) -> List[Dict[str, Any]]: + """将一层列表的相邻值合并，并返回每一个不同值的stat、end、元素值 + + Args: + lst (List[Any]): _description_ + + Returns: + List[Dict[str, Any]]: 合并后的列表结果，形如 + [ + { + "star": x, + "end": x, + "element": x, + }, + ] + """ + merge_lst = [] + if len(lst) == 0: + return lst + elif len(lst) == 1: + return {"start": 0, "end": 0, "element": lst[0]} + start = 0 + end = 0 + last_element = lst[end] + for i, element in enumerate(lst): + if i == 0: + continue + if i == len(lst) - 1: + if element != last_element: + dct = {"start": start, "end": end, "element": last_element} + merge_lst.append(dct) + last = {"start": len(lst) - 1, "end": i, "element": element} + merge_lst.append(last) + else: + last = {"start": start, "end": i, "element": element} + merge_lst.append(last) + break + + if element != last_element: + dct = {"start": start, "end": end, "element": last_element} + merge_lst.append(dct) + start = i + last_element = element + end = i + return merge_lst + + +def flatten2generator(lst: Iterable, ignored_iterable_types: List = None): + """将一个嵌套迭代器展开成生成器， + + Args: + lst (Iterable): 待展开的迭代器 + ignored_iterable_types (_type_, List): 如果待展开的迭代器在该目标列表中，则不展开. Defaults to None. + + Yields: + _type_: 不是迭代器的类型，或者 ignored_iterable_types中的类型 + """ + if ignored_iterable_types is None: + ignored_iterable_types = [] + for element in lst: + if ( + isinstance(element, Iterable) + and type(element) not in ignored_iterable_types + ): + for subc in flatten2generator(element): + yield subc + else: + yield element + + +def flatten(lst: List, ignored_iterable_types=None) -> List: + """将 flatten_nested_iterable_2_generator展开的生成器转化为迭代器，容器目前使用 list + + Args: + lst (List): _description_ + ignored_iterable_types (_type_, List): 如果待展开的迭代器在该目标列表中，则不展开. Defaults to None. + + Returns: + List: _description_ + """ + return list(flatten2generator(lst, ignored_iterable_types=ignored_iterable_types)) + + +def get_current_strtime(fmt: str = "%Y-%m-%d %H:%M:%S") -> str: + current_time = time.strftime(fmt, time.localtime()) + return current_time + + +def advanced_count(df: Iterable) -> Dict: + """对迭代器中的数值内容进行统计 + + Args: + df (Iterable): 值为可统计的迭代器，如str, int, float等 + + Returns: + Dict: 统计结果 + """ + n_all = len(df) + count = Counter(df) + new_count = {"total": n_all} + for k, v in count.items(): + new_count[k] = v + new_count["{}_ratio".format(k)] = round(v / n_all * 100, 2) + return new_count + + +class CustomCounter(object): + def __init__(self, name: str) -> None: + """多类别统计器，支持输入值的类别，针对每种类别分别统计 + + Args: + name (str): _description_ + """ + self.name = name + self._category_col = "category" + self._value_col = "value" + self._df = pd.DataFrame(columns=[self._category_col, self._value_col]) + + def update(self, v, k: str = "default") -> None: + new = pd.DataFrame([{self._category_col: k, self._value_col: v}]) + self._df = pd.concat([self._df, new], axis=0) + + def advanced_count( + self, + ) -> Dict: + dct = {"total": self.simple_count()} + if len(self._df[self._category_col] != "default") > 0: + for k, k_df in self._df.groupby(self._category_col): + dct[k] = advanced_count(k_df[self._value_col]) + return dct + + def simple_count( + self, + ) -> Dict: + return advanced_count(self._df[self._value_col]) + + def count(self, is_simple: bool = False) -> Dict: + if is_simple: + return self.simple_count() + else: + return self.advanced_count() diff --git a/MuseV/MMCM/mmcm/vision/__init__.py b/MuseV/MMCM/mmcm/vision/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..f205a2dd0df6478abd44b294db851f1c3ee6814c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/__init__.py @@ -0,0 +1,34 @@ +from .human import ( + InsightfacePredictor, + FaceTrackerByYolo5DeepSort, + FaceClusterByInfomap, +) + +# wenlan depenon detectron2, which often failed, and would be removed +from .transition.TransNetV2.transnetv2_predictor import TransNetV2Predictor + +try: + from .feature_extractor.wenlan.wenlan_predictor import ( + WenLanVisualPredictor, + ) +except: + pass +from .transition.scene_transition_predictor import SceneTransitionPredictor +from .feature_extractor.taiyi_prefictor import TaiyiVisionFeatureExtractor +from .feature_extractor.vae_extractor import VAEFeatureExtractor + +from .vis.vis_video_map import vis_video_map + +from .video_map.vision_object import Role, Roles +from .video_map.video_map import VideoMap, VideoMapSeq +from .video_map.video_clip import VideoClip, VideoClipSeq +from .video_map.video_meta_info import VideoMetaInfo +from .video_map.load_video_map import load_video_map + +from .utils.path_util import ( + get_video_signature, + get_video_path_dct, + get_dir_file_map, + get_video_map_path_dct, + get_video_emd_path_dct, +) diff --git a/MuseV/MMCM/mmcm/vision/black_border.py b/MuseV/MMCM/mmcm/vision/black_border.py new file mode 100755 index 0000000000000000000000000000000000000000..e9d8b9be13d3e4e19b6821d59246dc1f4025d022 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/black_border.py @@ -0,0 +1,99 @@ +# -*- coding: utf-8 -*- + +import traceback +import argparse +import os + +from moviepy.editor import VideoFileClip +import numpy as np + + +# rmBlackBorder: remove the black borders of one image +# return: cropped image +def det_image_black_border( + src, # input image + thres, # threshold for cropping: sum([r,g,b] - [0,0,0](black)) + shrink, # number of pixels to shrink after the blackBorders removed +): + # remove the black border on both right and left side + nRow = src.shape[0] + nCol = src.shape[1] + left = 0 + right = nCol + + # for j in range(0, nCol): + # if src[:, j].mean() <= thres: + # left = j + 1 + # else: + # break + # + # for j in range(nCol - 1, -1, -1): + # if src[:, j].mean() <= thres: + # right = j + # else: + # break + + black_idx = np.where(src.mean(axis=0) <= thres)[0].tolist() + for i in black_idx: + if left < i < nCol // 2: + left = i + elif nCol // 2 < i < right: + right = i + + if right - left > 0: + left = left + shrink + right = right - shrink + else: + left = 0 + right = nCol + + # remove the black border on both up and down side + up = 0 + bottom = nRow + + # for i in range(0, nRow): + # if src[i, :].mean() <= thres: + # up = i + 1 + # else: + # break + # + # for i in range(nRow - 1, -1, -1): + # if src[i, :,].mean() <= thres: + # bottom = i + # else: + # break + + black_idx = np.where(src.mean(axis=1) <= thres)[0].tolist() + for i in black_idx: + if up < i < nRow // 2: + up = i + elif nRow // 2 < i < bottom: + bottom = i + + if bottom - up > 0: + top = up + shrink + bottom = bottom - shrink + else: + top = 0 + bottom = nRow + + return (left, top, right, bottom) + + +def det_video_black_border(video_path): + video = VideoFileClip(video_path) + duration = video.duration + test_duration = 600 + video = video.subclip( + t_start=duration / 2 - test_duration / 2, t_end=duration / 2 + test_duration / 2 + ) + frame_num = 0 + for frame in video.iter_frames(fps=1): + frame = frame.astype(np.int64) + if frame_num == 0: + frame_sum = frame + else: + frame_sum += frame + frame_num += 1 + frame = frame_sum / frame_num + return det_image_black_border(frame, 5, 0) diff --git a/MuseV/MMCM/mmcm/vision/config/CFG.py b/MuseV/MMCM/mmcm/vision/config/CFG.py new file mode 100755 index 0000000000000000000000000000000000000000..65174f8963626fb8714a0acd7f4b274a6eedcb21 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/config/CFG.py @@ -0,0 +1,89 @@ +"""使用easydict配置适用于工程的全局参数字典 +后面可以再拆分 线上、线下、各自业务的全局字典，在使用时指定 +""" + +from easydict import EasyDict as edct + +from ...utils.color_util import PolledColor +from .model_cfg import ModelCfg + +CFG = edct() +CFG.application = None + +CFG.update(ModelCfg) +CFG.device = "cuda" +CFG.model_name = "StableDiffusion" # 从model_cfg中找到对应模型的路径 +CFG.pipe_name = "StableDiffusionPipeline" # 与diffusers中的pipeline类同名字符串 +CFG.scheduler = None # 与diffusers中的Scheduler类同名字符串 +CFG.requires_safety_checker = True # 是否使用 safety_checker +CFG.template_name = "default" # 用于将输入的参数字典转化成模型prompt输入 +CFG.prompt_type = "default" # prompt_type不影响代码运行，纯粹方便对prompt分类理解 +CFG.target_width = 512 +CFG.target_height = 512 +CFG.num_inference_steps = 50 +CFG.guidance_scale = 7.0 +CFG.strength = 0.8 +CFG.image_height_in_table = 240 +CFG.try_num_util_succeed = 20 # 每个prompt任务图像生成尝试次数，不成功就放弃 +CFG.seed = None # predictor 预测时的随机数生成器种子 +# 一些专门定义的分隔符 + +# 属性字符串中有该字符串时，会通过外积运算裂变成多个任务，其他属性一模一样 +CFG.task_fission_sep = "|" + +# 属性字符串中有该字符串时，会裂变成多个任务描述 +# 如`eyes`属性中有`small,black`，则真实文本会是`small eyes, black eyes`，任务数不会发生变化 +# 该部分还没有真正起作用，需要后面看怎么真正参数化，目前如果需要该功能，请在表格中记住使用`,`作为分隔符。 +CFG.atrtribute_fission_sep = "," + +CFG.time_str_format = "%Y-%m-%d %H:%M:%S" + +# 输出文本图像存储方式 +# 是否给存的结果增加审核列，便于候选审核 +CFG.add_checker_columns = False +CFG.validates = None + +# video_map相关算法 +CFG.SemanticsAlgo = "wenlan" +CFG.ClipTransitionAlgo = "TransnetV2" +CFG.SscneTransitionAlgo = "SceneSeg" +CFG.FaceAlgo = "insightface" +CFG.TrackAlgo = "deepsort" + +# 剪辑相关配置 +# 颜色可参考：http://www1.ynao.ac.cn/~jinhuahe/know_base/othertopics/computerissues/RGB_colortable.htm + +# PRODUCTION, DEVELOP, DEBUG +CFG.RunningMode = "DEVELOP" +CFG.TalkingDetectionTh = -0.2 +CFG.FocalHumanMaxid = 3 +CFG.MoviepyVideoClipReadOffset = 0.2 +CFG.RecallNum = 1 +CFG.RankNum = 1 + +# MusicInfo +CFG.MSSLyricInterInterval = 4 + +# VideoInfo +CFG.VideoStart = 0.15 +CFG.VideoEnd = 0.8 + +# VisualizationParameters +CFG.Font = "Courier" +# CFG.Font = "STXinwei" # 相对秀气的字体，比较适合MV +CFG.LyricFontSize = 25 +# LyricTitleFontSize = CFG.LyricFontSize * 1.1 + +# Debug +# 是否可视化clip中的帧信息，目前打开了会非常卡，默认关闭 +CFG.VisFrame = False +# 音乐转场点边界块，可视化颜色、宽度 +CFG.MusicTransitionEdgeColor = (51, 161, 201) # 孔雀蓝 +CFG.MusicTransitionEdgeSize = (20, 60) + +CFG.DebugFontSize = 30 +CFG.DebugTextStrokeWidth = 2 +CFG.DebugTextColors = ["red", "orange"] +CFG.DebugTextColorsCls = PolledColor(CFG.DebugTextColors) +CFG.DebugFrameTextDuration = 0.5 +CFG.DebugFrameTextColor = "red" diff --git a/MuseV/MMCM/mmcm/vision/config/__init__.py b/MuseV/MMCM/mmcm/vision/config/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/config/cfg_util.py b/MuseV/MMCM/mmcm/vision/config/cfg_util.py new file mode 100755 index 0000000000000000000000000000000000000000..62ff3836632cc179fec5ac555d827dd7bcbdad98 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/config/cfg_util.py @@ -0,0 +1,45 @@ +from typing import Dict, Callable, List +import os + +from ..utils.data_util import dict_has_keys, dict_get_keys +from .model_cfg import ModelCfg + + +def get_model_path( + model_names: List[str], + online_dir: str, + offline_dir: str, + download_func: Callable, +) -> Dict: + """get model_path dict by model_name. If not existed, do download. + + Args: + model_name (str): _description_ + online_dir (str): _description_ + offline_dir (str): _description_ + download_func (Callable): _description_ + + Returns: + Dict: _description_ + """ + if not dict_has_keys(ModelCfg, model_names): + print("please set online model_path at least for {}".format(model_names)) + return + else: + model_basename_dct = dict_get_keys(ModelCfg, model_names) + offline_path_dct = {} + for k, v in model_basename_dct.items(): + offline_path = os.path.join(offline_dir, v) + os.makedirs(os.path.dirname(offline_path), exist_ok=True) + if not os.path.exists(offline_path): + online_path = os.path.join(online_dir, v) + print( + "starting downloading models from {} to".format( + online_path, offline_path + ) + ) + download_func(online_path, offline_dir) + else: + print("load offline model from {}".format(offline_path)) + offline_path_dct[k] = offline_path + return offline_path_dct diff --git a/MuseV/MMCM/mmcm/vision/config/model_cfg.py b/MuseV/MMCM/mmcm/vision/config/model_cfg.py new file mode 100755 index 0000000000000000000000000000000000000000..3ec31f79c642bcf84fc51c502e8b287b4ccc1d6b --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/config/model_cfg.py @@ -0,0 +1,59 @@ +from easydict import EasyDict as edct + +ModelCfg = edct() + +# a full path of models list should be +# ModelCfg.StableDiffusion = { +# "model_path": str, +# "vae_path": str, +# } + +# the full path is os.path.join(ModelCfg.Online_Model_Dir, ModelCfg.model_name["k"]) +# Online_Model_Dir use cos + +ModelCfg.Online_Model_Dir = "/DeployModels/vision" +ModelCfg.Offline_Model_Dir = "/cfs/cfs-4a8cd28be/DeployModel/vision" + +# transition model +ModelCfg.TransnetV2 = {"model_path": "transition/transnetv2_pytorch_weights.pth"} + +# generation model path +Generation = edct() +## sd model_path +StableDiffusion = edct() +Generation.StableDiffusionModel = StableDiffusion +ModelCfg.Generation = Generation +StableDiffusion.StableDiffusion = { + "model_path": "sd-v1-4/snapshots/2881c082ee0dc70d9eeb645f1b150040a4b62767" +} +StableDiffusion.WaifuSD_V13_FP32 = { + "model_path": "waifu-diffusion-v1-3_FP32", +} +StableDiffusion.WaifuSD_V13_FP16 = { + "model_path": "waifu-diffusion-v1-3_FP16", +} +StableDiffusion.WaifuSD = StableDiffusion.WaifuSD_V13_FP32 +StableDiffusion.AnythingSD = { + "model_path": "anything-v3.0", +} +StableDiffusion.NovelAISDInformal = { + "model_path": "NovelAISDInformal", +} +StableDiffusion.TrinartSD = { + "model_path": "models--naclbit--trinart_stable_diffusion_v2/snapshots/0dcafd78d07345d30f3e7c12277693e0ffeeec72", +} +StableDiffusion.ArcherSD = { + "model_path": "archer-diffusion", +} +ModelCfg.TrinartSD = { + "model_path": "sd-v1-4/snapshots/2881c082ee0dc70d9eeb645f1b150040a4b62767", +} +StableDiffusion.PixelSD = { + "model_path": "All-In-One-Pixel-Model", +} +StableDiffusion.PixelArtSD = { + "model_path": "PixelArtSD", +} +StableDiffusion.MomokoE = { + "model_path": "momoko-e", +} diff --git a/MuseV/MMCM/mmcm/vision/data/__init__.py b/MuseV/MMCM/mmcm/vision/data/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..98d03b48925a2073963854499e6475ac92c0675b --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/data/__init__.py @@ -0,0 +1 @@ +from .video_dataset import MoviepyVideoDataset, OpenCVVideoDataset, DecordVideoDataset, ImagesSequentialDataset, PILImageSequentialDataset \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/data/image_dataset.py b/MuseV/MMCM/mmcm/vision/data/image_dataset.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/data/video_dataset.py b/MuseV/MMCM/mmcm/vision/data/video_dataset.py new file mode 100755 index 0000000000000000000000000000000000000000..a463498fb1a26359e189f7db8c3c51b4619437d2 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/data/video_dataset.py @@ -0,0 +1,494 @@ +import os +import itertools +from collections import namedtuple +from typing import Any, Iterator, List, Literal, Sequence +import math +from einops import rearrange + +from moviepy.editor import VideoFileClip +import torchvision +from torch.utils.data.dataset import Dataset, IterableDataset +from PIL import Image +import cv2 +import torch +import numpy as np + +from ...utils.path_util import get_dir_file_map +from ...utils.itertools_util import generate_sample_idxs, overlap2step, step2overlap + + +VideoDatasetOutput = namedtuple("video_dataset_output", ["data", "index"]) + + +def worker_init_fn(worker_id: int): + worker_info = torch.utils.data.get_worker_info() + dataset = worker_info.dataset # the dataset copy in this worker process + overall_start = 0 + overall_end = len(dataset) + # configure the dataset to only process the split workload + per_worker = int( + math.ceil((overall_end - overall_start) / float(worker_info.num_workers)) + ) + worker_id = worker_info.id + dataset_start = overall_start + worker_id * per_worker + dataset_end = min(overall_start + per_worker, overall_end) + dataset.sample_indexs = dataset.sample_indexs[dataset_start:dataset_end] + + +class SequentialDataset(IterableDataset): + def __init__( + self, + raw_datas, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + max_num_per_batch: int = None, + data_type: Literal["bgr", "rgb"] = "bgr", + channels_order: str = "t h w c", + sample_indexs: List[List[int]] = None, + ) -> None: + """_summary_ + + Args: + raw_datas (_type_): all original data + time_size (int): frames number of a clip + step (int): step of two windows + overlap (int, optional): overlap of two windows. Defaults to None. + sample_rate (int, optional): sample 1 evey sample_rate number. Defaults to 1. + drop_last (bool, optional): whether drop the last if length of last batch < time_size. Defaults to False. + """ + super().__init__() + self.time_size = time_size + if overlap is not None and step is None: + step = overlap2step(overlap, time_size) + if step is not None and overlap is None: + overlap = step2overlap(step, time_size) + self.overlap = overlap + self.step = step + self.sample_rate = sample_rate + self.drop_last = drop_last + self.raw_datas = raw_datas + self.max_num_per_batch = max_num_per_batch + if sample_indexs is not None: + self.sample_indexs = sample_indexs + else: + self.generate_sample_idxs() + self.current_pos = 0 + self.data_type = data_type + self.channels_order = channels_order + + def generate_sample_idxs( + self, + ): + self.sample_indexs = generate_sample_idxs( + total=self.total_frames, + window_size=self.time_size, + step=self.step, + sample_rate=self.sample_rate, + drop_last=self.drop_last, + max_num_per_window=self.max_num_per_batch, + ) + + def get_raw_datas( + self, + ): + return self.raw_datas + + def get_raw_data(self, index: int): + raise NotImplementedError + + def get_batch_raw_data(self, indexs: List[int]): + datas = [self.get_raw_data(i) for i in indexs] + datas = np.stack(datas, axis=0) + return datas + + def __len__(self): + return len(self.sample_indexs) + + def __iter__(self) -> Iterator[Any]: + return self + + def __getitem__(self, index): + sample_indexs = self.sample_indexs[index] + data = self.get_batch_raw_data(sample_indexs) + if self.channels_order != "t h w c": + data = rearrange(data, "t h w c -> {}".format(self.channels_order)) + sample_indexs = np.array(sample_indexs) + return VideoDatasetOutput(data, sample_indexs) + + def get_data(self, index): + return self.__getitem__(index) + + def __next__(self): + while self.current_pos < len(self.sample_indexs): + data = self.get_data(self.current_pos) + self.current_pos += 1 + return data + self.current_pos = 0 + raise StopIteration + + def preview(self, clip): + """show data clip, + play for image, video, and print for str list + + Args: + clip (_type_): _description_ + """ + raise NotImplementedError + + def close(self): + """ + close file handle if subclass open file + """ + raise NotImplementedError + + @property + def fps(self): + raise NotImplementedError + + @property + def total_frames(self): + raise NotImplementedError + + @property + def duration(self): + raise NotImplementedError + + @property + def width(self): + raise NotImplementedError + + @property + def height(self): + raise NotImplementedError + + +class ItemsSequentialDataset(SequentialDataset): + def __init__( + self, + raw_datas: Sequence, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + sample_indexs: List[List[int]] = None, + ) -> None: + super().__init__( + raw_datas, + time_size, + step, + overlap, + sample_rate, + drop_last, + sample_indexs=sample_indexs, + ) + + def get_raw_data(self, index: int): + return self.raw_datas[index] + + def prepare_raw_datas(self, raw_datas) -> Sequence: + return raw_datas + + @property + def total_frames(self): + return len(self.raw_datas) + + +class ListSequentialDataset(ItemsSequentialDataset): + def preview(self, clip): + print(f"type is {self.__class__.__name__}, num is {len(clip)}") + print(clip) + + +class ImagesSequentialDataset(ItemsSequentialDataset): + def __init__( + self, + img_dir: Sequence, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + data_type: Literal["bgr", "rgb"] = "bgr", + channels_order: str = "t h w c", + sample_indexs: List[List[int]] = None, + ) -> None: + self.imgs_path = sorted(get_dir_file_map(img_dir).values()) + super().__init__( + self.imgs_path, + time_size, + step, + overlap, + sample_rate, + drop_last, + data_ty=data_type, + channels_order=channels_order, + sample_indexs=sample_indexs, + ) + + +class PILImageSequentialDataset(ImagesSequentialDataset): + def __getitem__(self, index: int) -> Image.Image: + data, sample_indexs = super().__getitem__(index) + data = [Image.open(x) for x in data] + return VideoDatasetOutput(data, sample_indexs) + + +class MoviepyVideoDataset(SequentialDataset): + def __init__( + self, + path, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + data_type: Literal["bgr", "rgb"] = "bgr", + contenct_box: List[int] = None, + sample_indexs: List[List[int]] = None, + ) -> None: + self.path = path + self.f = self.prepare_raw_datas(self.path) + super().__init__( + self.f, + time_size, + step, + overlap, + sample_rate, + drop_last, + data_type=data_type, + sample_indexs=sample_indexs, + ) + self.contenct_box = contenct_box + + def prepare_raw_datas(self, path): + f = VideoFileClip(path) + return f + + def get_raw_data(self, index: int): + return self.f.get_frame(index * 1 / self.f.fps) + + @property + def fps(self): + return self.f.fps + + @property + def size(self): + return self.f.size + + @property + def total_frames(self): + return int(self.duration * self.fps) + + @property + def duration(self): + return self.f.duration + + @property + def width(self): + return self.f.w + + @property + def height(self): + return self.f.h + + def __next__( + self, + ): + video_clips = [] + cnt = 0 + frame_indexs = [] + + for frame in itertools.islice(self.video.iter_frames(), step=self.step): + if cnt >= self.total_frames: + raise StopIteration + else: + frame_indexs.append(cnt) + cnt += self.step + if len(video_clips) < self.time_size: + video_clips.append(frame) + else: + return_video_clips = video_clips + return_frame_indexs = frame_indexs + video_clips = [] + frame_indexs = [] + return VideoDatasetOutput(return_video_clips, return_frame_indexs) + + +class TorchVideoDataset(object): + pass + + +class OpenCVVideoDataset(SequentialDataset): + def __init__( + self, + path, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + data_type: Literal["bgr", "rgb"] = "bgr", + channels_order: str = "t h w c", + sample_indexs: List[List[int]] = None, + ) -> None: + self.path = path + self.f = self.prepare_raw_datas(path) + super().__init__( + self.f, + time_size, + step, + overlap, + sample_rate, + drop_last, + data_type=data_type, + channels_order=channels_order, + sample_indexs=sample_indexs, + ) + + def prepare_raw_datas(self, path): + f = cv2.VideoCapture(path) + return f + + def get_raw_data(self, index: int): + self.f.set(cv2.CAP_PROP_POS_FRAMES, index) + if index < 0 or index >= self.total_frames: + raise IndexError( + f"index must in [0, {self.total_frames -1 }], but given index" + ) + ret, frame = self.f.read() + if self.data_type == "rgb": + frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) + return frame + + def get_raw_data_by_time(self, idx): + raise NotImplementedError + + @property + def total_frames(self): + return int(self.f.get(cv2.CAP_PROP_FRAME_COUNT)) + + @property + def width(self): + return int(self.f.get(cv2.CAP_PROP_FRAME_WIDTH)) + + @property + def height(self): + return int(self.f.get(cv2.CAP_PROP_FRAME_HEIGHT)) + + @property + def durtion(self): + return self.total_frames / self.fps + + @property + def fps(self): + return self.f.get(cv2.CAP_PROP_FPS) + + +class DecordVideoDataset(SequentialDataset): + def __init__( + self, + path, + time_size: int, + step: int, + device: str, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + device_id: int = 0, + data_type: Literal["bgr", "rgb"] = "bgr", + channels_order: str = "t h w c", + sample_indexs: List[List[int]] = None, + ) -> None: + self.path = path + self.device = device + self.device_id = device_id + self.f = self.prepare_raw_datas(path) + super().__init__( + self.f, + time_size, + step, + overlap, + sample_rate, + drop_last, + data_type=data_type, + channels_order=channels_order, + sample_indexs=sample_indexs, + ) + + def prepare_raw_datas(self, path): + from decord import VideoReader + from decord import cpu, gpu + + if self.device == "cpu": + device = cpu(self.device_id) + else: + device = gpu(self.device_id) + with open(path, "rb") as f: + f = VideoReader(f, ctx=device) + return f + + # decord 的 颜色通道 通道默认是 rgb + def get_raw_data(self, index: int): + data = self.f[index].asnumpy() + if self.data_type == "bgr": + data = data[:, :, ::-1] + return data + + def get_batch_raw_data(self, indexs: List[int]): + data = self.f.get_batch(indexs).asnumpy() + + if self.data_type == "bgr": + data = data[:, :, :, ::-1] + return data + + @property + def total_frames(self): + return len(self.f) + + @property + def height(self): + return self.f[0].shape[0] + + @property + def width(self): + return self.f[0].shape[1] + + @property + def size(self): + return self.f[0].shape[:2] + + @property + def shape(self): + return self.f[0].shape + + +class VideoMapClipDataset(SequentialDataset): + def __init__( + self, + video_map: str, + raw_datas, + time_size: int, + step: int, + overlap: int = None, + sample_rate: int = 1, + drop_last: bool = False, + max_num_per_batch: int = None, + ) -> None: + self.video_map = video_map + super().__init__( + raw_datas, + time_size, + step, + overlap, + sample_rate, + drop_last, + max_num_per_batch, + ) + + def generate_sample_idxs(self): + # use video_map to generate matched sampled_index + raise NotImplementedError diff --git a/MuseV/MMCM/mmcm/vision/data/vision_writer.py b/MuseV/MMCM/mmcm/vision/data/vision_writer.py new file mode 100755 index 0000000000000000000000000000000000000000..a70f333dd0c320249099bb05ab75af611d24e65f --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/data/vision_writer.py @@ -0,0 +1,48 @@ +from typing import Sequence + +from numpy import ndarray +import cv2 +try: + import imageio +except ImportError: + imageio = None + + +def create_video(frames: Sequence[ndarray], out: str, fourcc: int, fps: int, + size: tuple) -> None: + """Create a video to save the optical flow. + ## from mmflow + Args: + frames (list, tuple): Image frames. + out (str): The output file to save visualized flow map. + fourcc (int): Code of codec used to compress the frames. + fps (int): Framerate of the created video stream. + size (tuple): Size of the video frames. + """ + # init video writer + video_writer = cv2.VideoWriter(out, fourcc, fps, size, True) + + for frame in frames: + video_writer.write(frame) + video_writer.release() + + +def create_gif(frames: Sequence[ndarray], + gif_name: str, + duration: float = 0.1) -> None: + """Create gif through imageio. + ## from mmflow + + Args: + frames (list[ndarray]): Image frames. + gif_name (str): Saved gif name + duration (int): Display interval (s). Default: 0.1. + """ + frames_rgb = [] + for frame in frames: + frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) + frames_rgb.append(frame_rgb) + if imageio is None: + raise RuntimeError('imageio is not installed,' + 'Please use “pip install imageio” to install') + imageio.mimsave(gif_name, frames_rgb, 'GIF', duration=duration) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..7b06941c22b06806e05a6c4cbd97f6e936f77a8f --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/__init__.py @@ -0,0 +1 @@ +# TODO: 有必要统一下 vision_clip_extractor diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/clip_vision_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/clip_vision_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..8f1378a9ac29f1eef5797ff5ed326c5731c51b48 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/clip_vision_extractor.py @@ -0,0 +1,368 @@ +import json +import os +import time +from typing import Literal, Optional, Union, List, Tuple +from tqdm import tqdm + +from PIL import Image +from torch import nn +from transformers import ( + CLIPVisionModelWithProjection, + CLIPImageProcessor, + AutoProcessor, +) + +import h5py +import torch +import numpy as np + +from ...data.extract_feature.base_extract_feature import BaseFeatureExtractor +from ...data.emb.h5py_emb import save_value_with_h5py + +from ..process.image_process import dynamic_crop_resize_image +from ..utils.data_type_util import convert_images + + +__all__ = [ + "ImageClipVisionFeatureExtractor", + "ImageClipVisionFeatureExtractorV2", + "ImageClipVisionFeatureExtractorV3", + "ImageClipVisionFeatureExtractorV4", + "VerstailSDLastHiddenState2ImageEmb", + "OriginLastHiddenState2ImageEmbd", + "OriginLastHiddenState2Poolout", +] + + +class ImageClipVisionFeatureExtractor(BaseFeatureExtractor): + """选择clip的image_embeds，一张图像的输出特征是N，根据模型的选择可能是512、768、1024 + + Args: + BaseFeatureExtractor (_type_): _description_ + """ + + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + ): + super().__init__(device, dtype, name) + self.pretrained_model_name_or_path = pretrained_model_name_or_path + # 保持和 ipadapter 一致 + self.image_encoder = CLIPVisionModelWithProjection.from_pretrained( + pretrained_model_name_or_path + ).to(device=device, dtype=dtype) + # TODO: 存在多种初始化代码，待后续统一 + if os.path.isdir(pretrained_model_name_or_path): + self.clip_image_processor = CLIPImageProcessor() + else: + self.clip_image_processor = AutoProcessor.from_pretrained( + pretrained_model_name_or_path + ) + + def extract_images( + self, + data: Union[str, List[str], Image.Image, List[Image.Image], np.ndarray], + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + data = convert_images(data, return_type="pil", input_rgb_order=input_rgb_order) + if target_height is not None and target_width is not None: + data = [ + dynamic_crop_resize_image( + image, + target_height=target_height, + target_width=target_width, + ) + for image in data + ] + + with torch.no_grad(): + clip_image = self.clip_image_processor( + images=data, return_tensors="pt" + ).pixel_values + emb = self.get_target_emb( + clip_image.to(device=self.device, dtype=self.dtype) + ) + if return_type == "numpy": + emb = emb.cpu().numpy() + return emb + + def get_target_emb(self, data): + outputs = self.image_encoder(data).image_embeds + return outputs + + def extract_video( + self, + video_dataset, + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + track_performance: bool = False, + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + embs = [] + sample_indexs = [] + if track_performance: + performance = {} + with torch.no_grad(): + for i, (batch, batch_index) in enumerate(video_dataset): + # TODO: 现阶段复用hugging face diffusers img2img pipeline中的抽取代码， + # 由于该代码目前只支持Image的预处理，故先将numpy.ndarray转换成PIL.Image + batch = [Image.fromarray(batch[b_i]) for b_i in range(len(batch))] + emb = self.extract_images( + data=batch, + target_width=target_width, + target_height=target_height, + return_type=return_type, + input_rgb_order=input_rgb_order, + ) + embs.append(emb) + sample_indexs.extend(batch_index) + sample_indexs = np.array(sample_indexs) + if return_type == "numpy": + embs = np.concatenate(embs, axis=0) + elif return_type == "torch": + embs = torch.concat(embs) + sample_indexs = torch.from_numpy(sample_indexs) + return sample_indexs, embs + + def extract( + self, + data: Union[str, List[str]], + data_type: Literal["image", "video"], + return_type: str = "numpy", + save_emb_path: str = None, + save_type: str = "h5py", + emb_key: str = "image_embeds", + sample_index_key: str = "sample_indexs", + insert_name_to_key: bool = False, + overwrite: bool = False, + input_rgb_order: str = "rgb", + save_sample_index: bool = True, + **kwargs, + ) -> Union[np.ndarray, torch.tensor]: + if self.name is not None and insert_name_to_key: + emb_key = f"{self.name}_{emb_key}" + sample_index_key = f"{self.name}_{sample_index_key}" + if save_emb_path is not None and os.path.exists(save_emb_path): + with h5py.File(save_emb_path, "r") as f: + if not overwrite and emb_key in f and sample_index_key in f: + return None + + if data_type == "image": + emb = self.extract_images( + data=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return emb + else: + raise NotImplementedError("save images emb") + elif data_type == "video": + sample_indexs, emb = self.extract_video( + video_dataset=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return sample_indexs, emb + else: + if save_type == "h5py": + self.save_video_emb_with_h5py( + save_emb_path=save_emb_path, + emb=emb, + emb_key=emb_key, + sample_indexs=sample_indexs, + sample_index_key=sample_index_key, + overwrite=overwrite, + save_sample_index=save_sample_index, + ) + return sample_indexs, emb + else: + raise ValueError(f"only support save_type={save_type}") + + @staticmethod + def save_images_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "image_embeds", + ) -> h5py.File: + save_value_with_h5py(save_emb_path, value=emb, key=emb_key) + + @staticmethod + def save_video_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "image_embeds", + sample_indexs: np.ndarray = None, + sample_index_key: str = "sample_indexs", + overwrite: bool = False, + save_sample_index: bool = True, + ) -> h5py.File: + save_value_with_h5py( + save_emb_path, + value=emb, + key=emb_key, + overwrite=overwrite, + dtype=np.float16, + ) + if save_sample_index: + save_value_with_h5py( + save_emb_path, + value=sample_indexs, + key=sample_index_key, + overwrite=overwrite, + dtype=np.uint32, + ) + + +class ImageClipVisionFeatureExtractorV2(ImageClipVisionFeatureExtractor): + """选择clip的 hidden_states[-2]，一张图像的输出特征是M*D，如257*1280， + + Args: + BaseFeatureExtractor (_type_): _description_ + """ + + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + ): + super().__init__(pretrained_model_name_or_path, name, device, dtype) + + def get_target_emb(self, data): + outputs = self.image_encoder(data, output_hidden_states=True).hidden_states[-2] + return outputs + + +class ImageClipVisionFeatureExtractorV3(ImageClipVisionFeatureExtractor): + """选择clip的 hidden_states[-2]，一张图像的输出特征是M*D，如257*1280， + + Args: + BaseFeatureExtractor (_type_): _description_ + """ + + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + ): + super().__init__(pretrained_model_name_or_path, name, device, dtype) + + def get_target_emb(self, data): + outputs = self.image_encoder(data, output_hidden_states=True).last_hidden_state + return outputs + + +class ImageClipVisionFeatureExtractorV4(ImageClipVisionFeatureExtractor): + """ + 参考 https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/deprecated/versatile_diffusion/pipeline_versatile_diffusion_image_variation.py#L114 + + Args: + BaseFeatureExtractor (_type_): _description_ + """ + + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + ): + super().__init__(pretrained_model_name_or_path, name, device, dtype) + + def get_target_emb(self, data): + encoder_output = self.image_encoder(data, output_hidden_states=True) + embeds = self.image_encoder.vision_model.post_layernorm( + encoder_output.last_hidden_state + ) + embeds = self.image_encoder.visual_projection(embeds) + embeds_pooled = embeds[:, 0:1] + embeds = embeds / torch.norm(embeds_pooled, dim=-1, keepdim=True) + return embeds + + +class OriginLastHiddenState2Poolout(nn.Module): + def __init__( + self, + hidden_size: int, + projection_dim: int, + layer_norm_eps: float, + ): + super().__init__() + self.post_layernorm = nn.LayerNorm(hidden_size, eps=layer_norm_eps) + self.visual_projection = nn.Linear(hidden_size, projection_dim, bias=False) + + def load_state_dict_from_pretrained(self, pretrained_model_name_or_path): + model_pretrained = torch.load( + os.path.join(pretrained_model_name_or_path, "pytorch_model.bin"), + map_location="cpu", + ) + post_layernorm_params = { + k.replace("vision_model.post_layernorm.", ""): v + for k, v in model_pretrained.items() + if "vision_model.post_layernorm." in k + } + self.post_layernorm.load_state_dict(post_layernorm_params) + visual_projection_params = { + k.replace("visual_projection.", ""): v + for k, v in model_pretrained.items() + if "visual_projection." in k + } + self.visual_projection.load_state_dict(visual_projection_params) + + @classmethod + def from_pretrained( + cls, pretrained_model_name_or_path: Optional[Union[str, os.PathLike]], **kwargs + ): + cfg_path = os.path.join(pretrained_model_name_or_path, "config.json") + with open(cfg_path, "r") as f: + config = json.load(f) + model = cls( + hidden_size=config["hidden_size"], + projection_dim=config["projection_dim"], + layer_norm_eps=config["layer_norm_eps"], + ) + model.load_state_dict_from_pretrained(pretrained_model_name_or_path) + return model + + def forward(self, data): + last_hidden_state = data + pooled_output = last_hidden_state[:, 0, :] + pooled_output = self.post_layernorm(pooled_output) + # image_embeds = self.visual_projection(pooled_output) + return pooled_output + + +class OriginLastHiddenState2ImageEmbd(OriginLastHiddenState2Poolout): + def __init__(self, hidden_size: int, projection_dim: int, layer_norm_eps: float): + super().__init__(hidden_size, projection_dim, layer_norm_eps) + + def forward(self, data): + pooled_output = super().forward(data) + image_embeds = self.visual_projection(pooled_output) + return image_embeds + + +class VerstailSDLastHiddenState2ImageEmb(OriginLastHiddenState2ImageEmbd): + def __init__(self, hidden_size: int, projection_dim: int, layer_norm_eps: float): + super().__init__(hidden_size, projection_dim, layer_norm_eps) + + def forward(self, data): + embeds = self.post_layernorm(data) + embeds = self.visual_projection(embeds) + embeds_pooled = embeds[:, 0:1] + embeds = embeds / torch.norm(embeds_pooled, dim=-1, keepdim=True) + return embeds diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/controlnet.py b/MuseV/MMCM/mmcm/vision/feature_extractor/controlnet.py new file mode 100644 index 0000000000000000000000000000000000000000..43696fcc4730fa9723c245b624f913201e5ef074 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/controlnet.py @@ -0,0 +1,1019 @@ +from copy import deepcopy +import inspect +from typing import Any, Callable, Dict, List, Literal, Tuple, Union +import warnings +import os +import random + +import h5py + +from diffusers.image_processor import VaeImageProcessor +import cv2 +from einops import rearrange, repeat +import numpy as np +import torch +from torch import nn +from PIL import Image +import controlnet_aux +from diffusers.models.controlnet import ControlNetModel +from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel + +from controlnet_aux.dwpose import draw_pose, pose2map, candidate2pose + +from ..process.image_process import dynamic_crop_resize_image + +from ..utils.data_type_util import convert_images +from ...data.emb.h5py_emb import save_value_with_h5py +from ...data.extract_feature.base_extract_feature import BaseFeatureExtractor +import json + + +def json_serializer(obj): + if isinstance(obj, np.ndarray): + return obj.tolist() + return obj + + +import time + + +def controlnet_tile_processor(img, **kwargs): + return img + + +class ControlnetProcessor(object): + def __init__( + self, + detector_name: str, + detector_id: str = None, + filename: str = None, + cache_dir: str = None, + device: str = "cpu", + dtype: torch.dtype = torch.float32, + processor_params: Dict = None, + processor_name: str = None, + ) -> None: + self.detector_name = detector_name + self.detector_id = detector_id + self.processor_name = processor_name + if detector_name is None: + self.processor = None + self.processor_params = {} + if isinstance(processor_name, str) and "tile" in processor_name: + self.processor = controlnet_tile_processor + else: + processor_cls = controlnet_aux.__dict__[detector_name] + processor_cls_argspec = inspect.getfullargspec(processor_cls.__init__) + self.processor_params = ( + processor_params if processor_params is not None else {} + ) + if not hasattr(processor_cls, "from_pretrained"): + self.processor = processor_cls() + else: + self.processor = processor_cls.from_pretrained( + detector_id, + cache_dir=cache_dir, + filename=filename, + **self.processor_params, + ) + if hasattr(self.processor, "to"): + self.processor = self.processor.to(device=device) + self.device = device + self.dtype = dtype + + def __call__( + self, + data: Union[ + Image.Image, List[Image.Image], str, List[str], np.ndarray, torch.Tensor + ], + data_channel_order: str, + target_width: int = None, + target_height: int = None, + return_type: Literal["pil", "np", "torch"] = "np", + return_data_channel_order: str = "b h w c", + processor_params: Dict = None, + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + # TODO： 目前采用二选一的方式，后续可以改进为增量更新 + processor_params = processor_params if processor_params is not None else {} + data = convert_images( + data, + return_type="pil", + input_rgb_order=input_rgb_order, + return_rgb_order=return_rgb_order, + data_channel_order=data_channel_order, + ) + height, width = data[0].height, data[0].width + if target_width is None: + target_width = width + if target_height is None: + target_height = height + + data = [ + dynamic_crop_resize_image( + image, target_height=target_height, target_width=target_width + ) + for image in data + ] + if self.processor is not None: + data = [self.processor(image, **processor_params) for image in data] + + # return_pose_only (bool): if true, only return pose keypoints in array format + if "return_pose_only" in processor_params.keys(): + if ( + self.detector_name == "DWposeDetector" + and processor_params["return_pose_only"] + ): + # (18, 2) + # (1, 18) + # (2, 21, 2) + # (1, 68, 2) + # j=json.dumps(data) + # json_str = json.dumps(data, default=json_serializer) + # return json_str + # print(len(data)) + + item_lsit = [] + for candidate, subset in data: + # candidate shape (1, 134, 2) + # subset (1, 134) + # print(candidate.shape) + # print(subset.shape) + subset = np.expand_dims(subset, -1) + item = np.concatenate([candidate, subset], -1) + # print(item.shape) + max_num = 20 + if item.shape[0] > max_num: + item = item[:max_num] + + if item.shape[0] < max_num: + pad_num = max_num - item.shape[0] + item = np.pad(item, ((0, pad_num), (0, 0), (0, 0))) + # print(item.shape) + # print() + + item_lsit.append(item) + + return np.stack(item_lsit, axis=0) # b, num_candidates, 134, 3 + + if return_type == "pil": + return data + data = np.stack([np.asarray(image) for image in data], axis=0) + if return_data_channel_order != "b h w c": + data = rearrange(data, "b h w c -> {}".format(return_data_channel_order)) + if return_type == "np": + return data + if return_type == "torch": + data = torch.from_numpy(data) + return data + + +class MultiControlnetProcessor(object): + def __init__(self, processors: List[ControlnetProcessor]) -> None: + self.processors = processors + + def __call__( + self, + data: Union[ + Image.Image, List[Image.Image], str, List[str], np.ndarray, torch.Tensor + ], + data_channel_order: str, + target_width: int = None, + target_height: int = None, + return_type: Literal["pil", "np", "torch"] = "np", + return_data_channel_order: str = "b h w c", + processor_params: List[Dict] = None, + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + if processor_params is not None: + assert isinstance( + processor_params, list + ), f"type of datas should be list, but given {type(datas)}" + assert len(processor_params) == len( + self.processors + ), f"length of datas({len(processor_params)}) be same as of {len(self.processors)}" + datas = [ + processor( + data=data, + data_channel_order=data_channel_order, + target_height=target_height, + target_width=target_width, + return_type=return_type, + return_data_channel_order=return_data_channel_order, + input_rgb_order=input_rgb_order, + processor_params=processor_params[i], + ) + for i, processor in enumerate(self.processors) + ] + return datas + + +class ControlnetFeatureExtractor(BaseFeatureExtractor): + def __init__( + self, + model_path: str, + detector_name: str, + detector_id: str, + device: str = "cpu", + dtype=torch.float32, + name: str = None, + # /group/30065/users/public/muse/models/stable-diffusion-v1-5/vae/config.json + vae_config_block_out_channels: int = 4, + processor_params: Dict = None, + filename=None, + cache_dir: str = None, + ): + super().__init__(device, dtype, name) + self.model_path = model_path + self.processor = ControlnetProcessor( + detector_name=detector_name, + detector_id=detector_id, + filename=filename, + cache_dir=cache_dir, + device=device, + dtype=dtype, + ) + self.vae_scale_factor = 2 ** (vae_config_block_out_channels - 1) + self.control_image_processor = VaeImageProcessor( + vae_scale_factor=self.vae_scale_factor, + do_convert_rgb=True, + do_normalize=False, + ) + self.controlnet = ControlNetModel.from_pretrained( + model_path, + ).to(device=device, dtype=dtype) + self.detector_name = detector_name + + def emb_name(self, width, height): + return "{}_w={}_h={}_emb".format(self.name, width, height) + + def prepare_image( + self, + image, # b c t h w + width, + height, + ): + if isinstance(image, np.ndarray): + image = torch.from_numpy(image) + if image.ndim == 5: + image = rearrange(image, "b c t h w-> (b t) c h w") + if height is None: + height = image.shape[-2] + if width is None: + width = image.shape[-1] + width, height = ( + x - x % self.control_image_processor.vae_scale_factor + for x in (width, height) + ) + image = image / 255.0 + # image = torch.nn.functional.interpolate(image, size=(height, width)) + do_normalize = self.control_image_processor.config.do_normalize + if image.min() < 0: + warnings.warn( + "Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] " + f"when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]", + FutureWarning, + ) + do_normalize = False + if do_normalize: + image = self.control_image_processor.normalize(image) + return image + + def extract_images( + self, + data: Union[str, List[str], Image.Image, List[Image.Image], np.ndarray], + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + data_channel_order: str = "b h w c", + processor_params: Dict = None, + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + data = self.processor( + data, + data_channel_order=data_channel_order, + target_height=target_height, + target_width=target_width, + return_type="torch", + processor_params=processor_params, + return_data_channel_order="b c h w", + input_rgb_order=input_rgb_order, + return_rgb_order=return_rgb_order, + ) + + # return_pose_only (bool): if true, only return pose keypoints in array format + if "return_pose_only" in processor_params.keys(): + if ( + self.detector_name == "DWposeDetector" + and processor_params["return_pose_only"] + ): + return data + batch = self.prepare_image(image=data, width=target_width, height=target_height) + + with torch.no_grad(): + batch = batch.to(self.device, dtype=self.dtype) + emb = self.controlnet.controlnet_cond_embedding(batch) + if return_type == "numpy": + emb = emb.cpu().numpy() + + return emb + + def extract_video( + self, + video_dataset, + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + processor_params: Dict = None, + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + embs = [] + sample_indexs = [] + with torch.no_grad(): + for i, (batch, batch_index) in enumerate(video_dataset): + # print(f"============== extract img begin") + # print(batch.shape) + t0 = time.time() + emb = self.extract_images( + data=batch, + target_width=target_width, + target_height=target_height, + return_type=return_type, + processor_params=processor_params, + input_rgb_order=input_rgb_order, + return_rgb_order=return_rgb_order, + ) + torch.cuda.synchronize() + t1 = time.time() + + # print(f"============== extract img end TIME COST:{t1-t0}\n") + + embs.append(emb) + sample_indexs.extend(batch_index) + + sample_indexs = np.array(sample_indexs) + + # return_pose_only (bool): if true, only return pose keypoints in array format + if "return_pose_only" in processor_params.keys(): + if ( + self.detector_name == "DWposeDetector" + and processor_params["return_pose_only"] + ): + embs = np.concatenate(embs, axis=0) + return sample_indexs, embs + + if return_type == "numpy": + embs = np.concatenate(embs, axis=0) + elif return_type == "torch": + embs = torch.concat(embs, dim=0) + sample_indexs = torch.from_numpy(sample_indexs) + return sample_indexs, embs + + def extract( + self, + data: Union[str, List[str]], + data_type: Literal["image", "video"], + return_type: str = "numpy", + save_emb_path: str = None, + save_type: str = "h5py", + emb_key: str = "emb", + sample_index_key: str = "sample_indexs", + insert_name_to_key: bool = False, + overwrite: bool = False, + target_width: int = None, + target_height: int = None, + save_sample_index: bool = True, + processor_params: Dict = None, + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + **kwargs, + ) -> Union[np.ndarray, torch.tensor]: + if self.name is not None and insert_name_to_key: + emb_key = f"{self.name}_{emb_key}" + sample_index_key = f"{self.name}_{sample_index_key}" + if save_emb_path is not None and os.path.exists(save_emb_path): + with h5py.File(save_emb_path, "r") as f: + if not overwrite and emb_key in f and sample_index_key in f: + return None + + if data_type == "image": + emb = self.extract_images( + data=data, + return_type=return_type, + target_height=target_height, + target_width=target_width, + processor_params=processor_params, + input_rgb_order=input_rgb_order, + return_rgb_order=return_rgb_order, + ) + if save_emb_path is None: + return emb + else: + raise NotImplementedError("save images emb") + elif data_type == "video": + sample_indexs, emb = self.extract_video( + video_dataset=data, + return_type=return_type, + processor_params=processor_params, + input_rgb_order=input_rgb_order, + return_rgb_order=return_rgb_order, + target_height=target_height, + target_width=target_width, + **kwargs, + ) + if save_emb_path is None: + return sample_indexs, emb + else: + if save_type == "h5py": + self.save_video_emb_with_h5py( + save_emb_path=save_emb_path, + emb=emb, + emb_key=emb_key, + sample_indexs=sample_indexs, + sample_index_key=sample_index_key, + save_sample_index=save_sample_index, + overwrite=overwrite, + ) + return sample_indexs, emb + else: + raise ValueError(f"only support save_type={save_type}") + + @staticmethod + def save_video_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "emb", + sample_indexs: np.ndarray = None, + sample_index_key: str = "sample_indexs", + overwrite: bool = False, + save_sample_index: bool = True, + ) -> h5py.File: + save_value_with_h5py(save_emb_path, value=emb, key=emb_key, overwrite=overwrite) + if save_sample_index: + save_value_with_h5py( + save_emb_path, + value=sample_indexs, + key=sample_index_key, + overwrite=overwrite, + dtype=np.uint32, + ) + + +def get_controlnet_params( + controlnet_names: Union[ + Literal[ + "pose", + "pose_body", + "pose_hand", + "pose_face", + "pose_hand_body", + "pose_hand_face", + "pose_all", + "dwpose", + "canny", + "hed", + "hed_scribble", + "depth", + "pidi", + "normal_bae", + "lineart", + "lineart_anime", + "zoe", + "sam", + "mobile_sam", + "leres", + "content", + "face_detector", + ], + List[str], + ], + detect_resolution: int = None, + image_resolution: int = None, + include_body: bool = False, + include_hand: bool = False, + include_face: bool = False, + hand_and_face: bool = None, +) -> Dict: + """通过简单 字符串参数就选择配置好的完整controlnet参数 + + Args: + controlnet_conds (Union[ Literal[ "pose", "canny", "hed", "hed_scribble", "depth", "pidi", "normal_bae", "lineart", "lineart_anime", "zoe", "sam", "mobile_sam", "leres", "content", "face_detector", ], List[str], ]): _description_ + detect_resolution (int, optional): controlnet_aux图像处理需要的参数，尽量是64的整倍数. Defaults to None. + image_resolution (int, optional): controlnet_aux图像处理需要的参数，尽量是64的整倍数. Defaults to None. + include_body (bool, optional): controlnet 是否包含身体. Defaults to False. + hand_and_face (bool, optional): pose controlnet 是否包含头和身体. Defaults to False. + + Returns: + Dict: ControlnetProcessor需要的字典参数 + """ + controlnet_cond_maps = { + "pose": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": include_body, + "include_hand": include_hand, + "include_face": include_face, + "hand_and_face": hand_and_face, + }, + }, + "pose_body": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": True, + "include_hand": False, + "include_face": False, + "hand_and_face": False, + }, + }, + "pose_hand": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": False, + "include_hand": True, + "include_face": False, + "hand_and_face": False, + }, + }, + "pose_face": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": False, + "include_hand": False, + "include_face": True, + "hand_and_face": False, + }, + }, + "pose_hand_body": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": True, + "include_hand": True, + "include_face": False, + "hand_and_face": False, + }, + }, + "pose_hand_face": { + "middle": "pose", + "detector_name": "OpenposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": False, + "include_hand": True, + "include_face": True, + "hand_and_face": True, + }, + }, + "dwpose": { + "middle": "dwpose", + "detector_name": "DWposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "dwpose_face": { + "middle": "dwpose", + "detector_name": "DWposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_hand": False, + "include_body": False, + }, + }, + "dwpose_hand": { + "middle": "dwpose", + "detector_name": "DWposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_face": False, + "include_body": False, + }, + }, + "dwpose_body": { + "middle": "dwpose", + "detector_name": "DWposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_face": False, + "include_hand": False, + }, + }, + "dwpose_body_hand": { + "middle": "dwpose", + "detector_name": "DWposeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_face": False, + "include_hand": True, + "include_body": True, + }, + }, + "canny": { + "middle": "canny", + "detector_name": "CannyDetector", + # "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_canny", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "tile": { + "middle": "tile", + "detector_name": None, + "detector_id": None, + "controlnet_model_path": "lllyasviel/control_v11f1e_sd15_tile", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "include_body": include_body, + "hand_and_face": hand_and_face, + }, + }, + # 隶属线条检测 + "hed": { + "middle": "hed", + "detector_name": "HEDdetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/sd-controlnet-hed", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "hed_scribble": { + "middle": "hed", + "detector_name": "HEDdetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_scribble", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "depth": { + "middle": "depth", + "detector_name": "MidasDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11f1p_sd15_depth", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "pidi": { + "middle": "pidi", + "detector_name": "PidiNetDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11f1p_sd15_depth", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "normal_bae": { + "middle": "normal_bae", + "detector_name": "NormalBaeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_normalbae", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "lineart": { + "middle": "lineart", + "detector_name": "LineartDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15_lineart", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + "coarse": True, + }, + }, + "lineart_anime": { + "middle": "lineart_anime", + "detector_name": "LineartAnimeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11p_sd15s2_lineart_anime", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "zoe": { + "middle": "zoe", + "detector_name": "ZoeDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11f1p_sd15_depth", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "sam": { + "middle": "sam", + "detector_name": "SamDetector", + "detector_id": "ybelkada/segment-anything", + "processor_cls_params": {"subfolder": "checkpoints"}, + "controlnet_model_path": "lllyasviel/control_v11p_sd15_seg", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "mobile_sam": { + "middle": "mobile_sam", + "detector_name": "SamDetector", + "detector_id": "dhkim2810/MobileSAM", + "processor_cls_params": { + "subfolder": "checkpoints", + "model_type": "vit_t", + "filename": "mobile_sam.pt", + }, + "controlnet_model_path": "lllyasviel/control_v11p_sd15_seg", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "leres": { + "middle": "leres", + "detector_name": "LeresDetector", + "detector_id": "lllyasviel/Annotators", + "controlnet_model_path": "lllyasviel/control_v11f1p_sd15_depth", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + # error + "content": { + "middle": "content", + "detector_name": "ContentShuffleDetector", + "controlnet_model_path": "lllyasviel/control_v11e_sd15_shuffle", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + }, + "face_detector": { + "middle": "face_detector", + "detector_name": "MediapipeFaceDetector", + "processor_params": { + "detect_resolution": detect_resolution, + "image_resolution": image_resolution, + }, + "controlnet_model_path": "lllyasviel/control_v11p_sd15_openpose", + }, + } + + def complete(dct): + if "detector_id" not in dct: + dct["detector_id"] = None + if "processor_cls_params" not in dct: + dct["processor_cls_params"] = None + return dct + + if isinstance(controlnet_names, str): + return complete(controlnet_cond_maps[controlnet_names]) + else: + params = [complete(controlnet_cond_maps[name]) for name in controlnet_names] + return params + + +def load_controlnet_model( + controlnet_names: Union[str, List[str]], + device: str, + dtype=torch.dtype, + need_controlnet_processor: bool = True, + need_controlnet=True, + detect_resolution: int = None, + image_resolution: int = None, + include_body: bool = False, + include_face: bool = False, + include_hand: bool = False, + hand_and_face: bool = None, +) -> Tuple[nn.Module, Callable, Dict]: + controlnet_params = get_controlnet_params( + controlnet_names, + detect_resolution=detect_resolution, + image_resolution=image_resolution, + include_body=include_body, + include_face=include_face, + hand_and_face=hand_and_face, + include_hand=include_hand, + ) + if need_controlnet_processor: + if not isinstance(controlnet_params, list): + controlnet_processor = ControlnetProcessor( + detector_name=controlnet_params["detector_name"], + detector_id=controlnet_params["detector_id"], + processor_params=controlnet_params["processor_cls_params"], + device=device, + dtype=dtype, + processor_name=controlnet_params["middle"], + ) + processor_params = controlnet_params["processor_params"] + else: + controlnet_processor = MultiControlnetProcessor( + [ + ControlnetProcessor( + detector_name=controlnet_param["detector_name"], + detector_id=controlnet_param["detector_id"], + processor_params=controlnet_param["processor_cls_params"], + device=device, + dtype=dtype, + processor_name=controlnet_param["middle"], + ) + for controlnet_param in controlnet_params + ] + ) + processor_params = [ + controlnet_param["processor_params"] + for controlnet_param in controlnet_params + ] + else: + controlnet_processor = None + processor_params = None + + if need_controlnet: + if isinstance(controlnet_params, List): + # TODO: support MultiControlNetModel.save_pretrained str path + controlnet = MultiControlNetModel( + [ + ControlNetModel.from_pretrained(d["controlnet_model_path"]) + for d in controlnet_params + ] + ) + else: + controlnet_model_path = controlnet_params["controlnet_model_path"] + controlnet = ControlNetModel.from_pretrained(controlnet_model_path) + controlnet = controlnet.to(device=device, dtype=dtype) + else: + controlnet = None + + return controlnet, controlnet_processor, processor_params + + +def prepare_image( + image, # b c t h w + image_processor: Callable, + width=None, + height=None, + return_type: Literal["numpy", "torch"] = "numpy", +): + if isinstance(image, List) and isinstance(image[0], str): + raise NotImplementedError + if isinstance(image, List) and isinstance(image[0], np.ndarray): + image = np.concatenate(image, axis=0) + if isinstance(image, np.ndarray): + image = torch.from_numpy(image) + if image.ndim == 5: + image = rearrange(image, "b c t h w-> (b t) c h w") + if height is None: + height = image.shape[-2] + if width is None: + width = image.shape[-1] + width, height = (x - x % image_processor.vae_scale_factor for x in (width, height)) + if height != image.shape[-2] or width != image.shape[-1]: + image = torch.nn.functional.interpolate( + image, size=(height, width), mode="bilinear" + ) + image = image.to(dtype=torch.float32) / 255.0 + do_normalize = image_processor.config.do_normalize + if image.min() < 0: + warnings.warn( + "Passing `image` as torch tensor with value range in [-1,1] is deprecated. The expected value range for image tensor is [0,1] " + f"when passing as pytorch tensor or numpy Array. You passed `image` with value range [{image.min()},{image.max()}]", + FutureWarning, + ) + do_normalize = False + + if do_normalize: + image = image_processor.normalize(image) + if return_type == "numpy": + image = image.numpy() + return image + + +class PoseKPs2ImgConverter(object): + def __init__( + self, + target_width: int, + target_height: int, + num_candidates: int = 10, + image_processor: Callable = None, + include_body: bool = True, + include_face: bool = False, + hand_and_face: bool = None, + include_hand: bool = True, + ) -> None: + self.target_width = target_width + self.target_height = target_height + self.num_candidates = num_candidates + self.image_processor = image_processor + self.include_body = include_body + self.include_face = include_face + self.hand_and_face = hand_and_face + self.include_hand = include_hand + + def __call__(self, kps: np.array) -> Any: + # draw pose + # (b, max_num=10, 134, 3) last dim, x,y,score + num_candidates = 0 + for idx_t in range(self.num_candidates): + if np.sum(kps[:, idx_t, :, :]) == 0: + num_candidates = idx_t + break + if num_candidates > 0: + kps = kps[:, 0:num_candidates, :, :] + candidate = kps[..., :2] + subset = kps[..., 2] + + poses = [ + candidate2pose( + candidate[i], + subset[i], + include_body=self.include_body, + include_face=self.include_face, + hand_and_face=self.hand_and_face, + include_hand=self.include_hand, + ) + for i in range(candidate.shape[0]) + ] + pose_imgs = [ + pose2map( + pose, + self.target_height, + self.target_width, + min(self.target_height, self.target_width), + min(self.target_height, self.target_width), + ) + for pose in poses + ] + pose_imgs = np.stack(pose_imgs, axis=0) # b h w c + else: + pose_imgs = np.zeros( + shape=(kps.shape[0], self.target_height, self.target_width, 3), + dtype=np.uint8, + ) + pose_imgs = rearrange(pose_imgs, "b h w c -> b c h w") + + if self.image_processor is not None: + pose_imgs = prepare_image( + image=pose_imgs, + width=self.target_width, + height=self.target_height, + image_processor=self.image_processor, + return_type="numpy", + ) + + return pose_imgs diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/insight_face_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/insight_face_extractor.py new file mode 100644 index 0000000000000000000000000000000000000000..4c732d4309edd95f5e4ada3c8c6bda2cd1dc5f6c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/insight_face_extractor.py @@ -0,0 +1,260 @@ +import os +import time +from typing import Literal, Union, List, Tuple +from tqdm import tqdm + +from PIL import Image + +from transformers import ( + CLIPVisionModelWithProjection, + CLIPImageProcessor, +) + +import h5py +import torch +import numpy as np + +from ...data.extract_feature.base_extract_feature import BaseFeatureExtractor +from ...data.emb.h5py_emb import save_value_with_h5py + +from ..process.image_process import dynamic_crop_resize_image +from ..utils.data_type_util import convert_images + +from .clip_vision_extractor import ImageClipVisionFeatureExtractorV2 + + +class InsightFaceExtractor(BaseFeatureExtractor): + """选择clip的image_embeds，一张图像的输出特征是N，根据模型的选择可能是512、768、1024 + + Args: + BaseFeatureExtractor (_type_): _description_ + """ + + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + model_name: str = "buffalo_l", + allowed_modules: List[str] = ["detection", "recognition"], + providers: List[str] = ["CUDAExecutionProvider", "CPUExecutionProvider"], + need_align_face: bool = False, + ): + from insightface.app import FaceAnalysis + + super().__init__(device, dtype, name) + self.pretrained_model_name_or_path = pretrained_model_name_or_path + self.extractor = FaceAnalysis( + name=model_name, + root=pretrained_model_name_or_path, + allowed_modules=allowed_modules, + providers=providers, + ) + self.extractor.prepare(ctx_id=0, det_size=(640, 640)) + self.need_align_face = need_align_face + + def extract_images( + self, + data: Union[str, List[str], Image.Image, List[Image.Image], np.ndarray], + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + data = convert_images( + data, + return_type="pil", + input_rgb_order=input_rgb_order, + return_rgb_order="bgr", + ) + if target_height is not None and target_width is not None: + data = [ + dynamic_crop_resize_image( + image, + target_height=target_height, + target_width=target_width, + ) + for image in data + ] + data = [np.array(x.convert("RGB"))[:, :, ::-1] for x in data] + with torch.no_grad(): + faces = [self.extractor.get(x) for x in data] + + emb = [self.get_target_emb(x) for x in faces] + if self.need_align_face: + from insightface.utils import face_align + + align_face_image = [ + face_align.norm_crop(x, landmark=faces[i][0].kps, image_size=224) + for i, x in enumerate(data) + ] + else: + align_face_image = None + emb = np.concatenate(np.expand_dims(emb, axis=0), axis=0) + if return_type == "torch": + emb = torch.from_numpy(emb).to(device=self.device) + return emb, align_face_image + + def get_target_emb(self, data): + outputs = data[0]["embedding"] + return outputs + + def extract_video( + self, + video_dataset, + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + track_performance: bool = False, + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + embs = [] + sample_indexs = [] + if track_performance: + performance = {} + if self.need_align_face: + align_face_images = [] + else: + align_face_images = None + with torch.no_grad(): + for i, (batch, batch_index) in enumerate(video_dataset): + # TODO: 现阶段复用hugging face diffusers img2img pipeline中的抽取代码， + # 由于该代码目前只支持Image的预处理，故先将numpy.ndarray转换成PIL.Image + batch = [Image.fromarray(batch[b_i]) for b_i in range(len(batch))] + emb, align_face_image = self.extract_images( + data=batch, + target_width=target_width, + target_height=target_height, + return_type=return_type, + input_rgb_order=input_rgb_order, + ) + embs.append(emb) + sample_indexs.extend(batch_index) + if self.need_align_face: + align_face_images.append(align_face_image) + sample_indexs = np.array(sample_indexs) + if return_type == "numpy": + embs = np.concatenate(embs, axis=0) + elif return_type == "torch": + embs = torch.concat(embs) + sample_indexs = torch.from_numpy(sample_indexs) + return sample_indexs, embs, align_face_images + + def extract( + self, + data: Union[str, List[str]], + data_type: Literal["image", "video"], + return_type: str = "numpy", + save_emb_path: str = None, + save_type: str = "h5py", + emb_key: str = "image_embeds", + sample_index_key: str = "sample_indexs", + insert_name_to_key: bool = False, + overwrite: bool = False, + input_rgb_order: str = "rgb", + save_sample_index: bool = True, + **kwargs, + ) -> Union[np.ndarray, torch.tensor]: + if self.name is not None and insert_name_to_key: + emb_key = f"{self.name}_{emb_key}" + sample_index_key = f"{self.name}_{sample_index_key}" + if save_emb_path is not None and os.path.exists(save_emb_path): + with h5py.File(save_emb_path, "r") as f: + if not overwrite and emb_key in f and sample_index_key in f: + return None + + if data_type == "image": + emb = self.extract_images( + data=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return emb + else: + raise NotImplementedError("save images emb") + elif data_type == "video": + sample_indexs, emb = self.extract_video( + video_dataset=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return sample_indexs, emb + else: + if save_type == "h5py": + self.save_video_emb_with_h5py( + save_emb_path=save_emb_path, + emb=emb, + emb_key=emb_key, + sample_indexs=sample_indexs, + sample_index_key=sample_index_key, + overwrite=overwrite, + save_sample_index=save_sample_index, + ) + return sample_indexs, emb + else: + raise ValueError(f"only support save_type={save_type}") + + @staticmethod + def save_images_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "image_embeds", + ) -> h5py.File: + save_value_with_h5py(save_emb_path, value=emb, key=emb_key) + + @staticmethod + def save_video_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "image_embeds", + sample_indexs: np.ndarray = None, + sample_index_key: str = "sample_indexs", + overwrite: bool = False, + save_sample_index: bool = True, + ) -> h5py.File: + save_value_with_h5py( + save_emb_path, + value=emb, + key=emb_key, + overwrite=overwrite, + dtype=np.float16, + ) + if save_sample_index: + save_value_with_h5py( + save_emb_path, + value=sample_indexs, + key=sample_index_key, + overwrite=overwrite, + dtype=np.uint32, + ) + + +class InsightFaceExtractorNormEmb(InsightFaceExtractor): + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + model_name: str = "buffalo_l", + allowed_modules: List[str] = ["detection", "recognition"], + providers: List[str] = ["CUDAExecutionProvider", "CPUExecutionProvider"], + ): + super().__init__( + pretrained_model_name_or_path, + name, + device, + dtype, + model_name, + allowed_modules, + providers, + ) + + def get_target_emb(self, data): + outputs = data[0].normed_embedding + return outputs diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/taiyi_prefictor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/taiyi_prefictor.py new file mode 100755 index 0000000000000000000000000000000000000000..acab9d029bd82cfbd188484c73e3ae9267620618 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/taiyi_prefictor.py @@ -0,0 +1,135 @@ +import os +import time +from typing import Union, List, Tuple +from tqdm import tqdm + +from PIL import Image +from transformers import ( + BertForSequenceClassification, + BertTokenizer, + CLIPProcessor, + CLIPModel, +) +import torch +import numpy as np +from numpy import ndarray +from moviepy.editor import VideoFileClip + +from ..utils.path_util import get_video_signature +from ..video_map.video_map import VideoMap +from ..data.video_dataset import MoviepyVideoDataset, SequentialDataset +from ...utils.itertools_util import generate_sample_idxs + + +class ClipVisionFeatureExtractor(object): + def __init__(self, model_name: str, local_file: bool = True, device: str = "cpu"): + if device: + self.device = device + else: + self.device = "cuda" if torch.cuda.is_available() else "cpu" + self.clip_model = ( + CLIPModel.from_pretrained(model_name, local_files_only=local_file) + .eval() + .to(self.device) + ) + self.processor = CLIPProcessor.from_pretrained( + model_name, local_files_only=local_file + ) + + def image(self, img_paths): + image = self.processor( + images=[Image.open(i) for i in img_paths], return_tensors="pt" + ).to(self.device) + with torch.no_grad(): + image_features = self.clip_model.get_image_features(**image) + image_features = image_features / image_features.norm(dim=-1, keepdim=True) + return image_features.detach().cpu().numpy() + + def __call__(self, image): + return self.image(image) + + def predict_images( + self, image: Union[Image.Image, List[Image.Image], torch.Tensor] + ) -> np.ndarray: + if isinstance(image, str): + image = [image] + if isinstance(image, list) and isinstance(image[0], str): + image = [Image.open(i) for i in image] + image = self.processor(images=image, return_tensors="pt").to(self.device) + with torch.no_grad(): + image_features = self.clip_model.get_image_features(**image) + image_features = image_features / image_features.norm(dim=-1, keepdim=True) + return image_features.detach().cpu().numpy() + + def predict_clip( + self, clip: Union[Image.Image, List[Image.Image], torch.Tensor], batch_size: int + ) -> ndarray: + features = [] + num = len(clip) + windows = generate_sample_idxs( + num, window_size=batch_size, step=batch_size, drop_last=False + ) + for i, window in enumerate(windows): + sub_clip = clip[window] + feature = self.predict_images(sub_clip) + features.append(feature) + feature = np.concatenate(features, axis=0) + return features + + def predict_video( + video: Union[str, SequentialDataset], + video_map: VideoMap, + vf_extractor, + bbx_extr, + time_size: int = None, + step: int = None, + overlap: int = None, + sample_rate: int = None, + drop_last: bool = False, + max_frame_num_per_clip: int = 5, + ): + # prepare video + if isinstance(video, str): + video = MoviepyVideoDataset( + video, + time_size=time_size, + step=step, + overlap=overlap, + drop_last=drop_last, + sample_rate=sample_rate, + ) + if video_map.meta_info.content_box != video.content_box: + video.content_box = video_map.content_box + fps = 1 + max_frame_num = 5 + select_frame_idx = [] + select_frame_clip = [] + for i in range(len(video_map.clipseq)): + clip = video_map.clipseq[i] + if clip["cliptype"] == "transition": + continue + select_frame_num = int(min(np.ceil(clip["duration"] * fps), max_frame_num)) + clip_total_frame_num = clip["frame_end"] - clip["frame_start"] + frame_duration = clip_total_frame_num // (select_frame_num + 1) + for j in range(select_frame_num): + select_frame_idx.append(clip["frame_start"] + (j + 1) * frame_duration) + select_frame_clip.append(i) + + return video_map + + +class TaiyiVisionFeatureExtractor(ClipVisionFeatureExtractor): + def __init__( + self, + model_name: str = "clip-vit-large-patch14", + local_file: bool = True, + device: str = "cpu", + ): + """_summary_ + + Args: + model_name (str, optional): clip-vit-large-patch14 or openai/clip-vit-large-patch14. Defaults to "clip-vit-large-patch14". + local_file (bool, optional): _description_. Defaults to True. + device (str, optional): _description_. Defaults to 'cpu'. + """ + super().__init__(model_name, local_file, device) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/vae_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/vae_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..6280282869dceff160169702792304452b91dd81 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/vae_extractor.py @@ -0,0 +1,218 @@ +import sys +from multiprocessing.pool import Pool +import os +import logging +from typing import Union, List, Tuple, Literal + +import torch +import numpy as np +import pandas as pd +import h5py +import diffusers +from diffusers import AutoencoderKL +from diffusers.image_processor import VaeImageProcessor +from einops import rearrange +from PIL import Image +from transformers import CLIPTextModel, CLIPTokenizer + +from ...data.extract_feature.base_extract_feature import BaseFeatureExtractor +from ...data.emb.h5py_emb import save_value_with_h5py + +from ..process.image_process import dynamic_resize_image, dynamic_crop_resize_image +from ..utils.data_type_util import convert_images + + +class VAEFeatureExtractor(BaseFeatureExtractor): + def __init__( + self, + pretrained_model_name_or_path: str, + name: str = None, + device: str = "cpu", + dtype=torch.float32, + ): + super().__init__(device, dtype, name) + self.pretrained_model_name_or_path = pretrained_model_name_or_path + vae = AutoencoderKL.from_pretrained( + pretrained_model_name_or_path, subfolder="vae" + ) + vae.requires_grad_(False) + self.vae = vae.to(device=device, dtype=dtype) + vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1) + self.image_processor = VaeImageProcessor(vae_scale_factor=vae_scale_factor) + + def extract_images( + self, + data: Union[str, List[str], Image.Image, List[Image.Image], np.ndarray], + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + data = convert_images(data, return_type="pil", input_rgb_order=input_rgb_order) + if target_height is not None and target_width is not None: + data = [ + dynamic_crop_resize_image( + image, + target_height=target_height, + target_width=target_width, + ) + for image in data + ] + batch = self.image_processor.preprocess(data).to( + device=self.device, dtype=self.dtype + ) + with torch.no_grad(): + # print("batch", batch.shape, batch.dtype, batch.device, self.vae.device) + emb = self.vae.encoder(batch) + quant_emb = self.vae.quant_conv(emb) + if return_type == "numpy": + emb = emb.cpu().numpy() + quant_emb = quant_emb.cpu().numpy() + return emb, quant_emb + + def extract_video( + self, + video_dataset, + target_width: int = None, + target_height: int = None, + return_type: str = "numpy", + track_performance: bool = False, + input_rgb_order: str = "rgb", + ) -> Union[np.ndarray, torch.Tensor]: + embs = [] + quant_embs = [] + sample_indexs = [] + if track_performance: + performance = {} + with torch.no_grad(): + for i, (batch, batch_index) in enumerate(video_dataset): + # TODO: 现阶段复用hugging face diffusers img2img pipeline中的抽取代码， + # 由于该代码目前只支持Image的预处理，故先将numpy.ndarray转换成PIL.Image + batch = [Image.fromarray(batch[b_i]) for b_i in range(len(batch))] + emb, quant_emb = self.extract_images( + data=batch, + target_width=target_width, + target_height=target_height, + return_type=return_type, + input_rgb_order=input_rgb_order, + ) + embs.append(emb) + quant_embs.append(quant_emb) + sample_indexs.extend(batch_index) + + sample_indexs = np.array(sample_indexs) + if return_type == "numpy": + embs = np.concatenate(embs, axis=0) + quant_embs = np.concatenate(quant_embs, axis=0) + elif return_type == "torch": + embs = torch.concat(embs) + quant_embs = torch.concat(quant_embs) + sample_indexs = torch.from_numpy(sample_indexs) + return sample_indexs, embs, quant_embs + + def extract( + self, + data: Union[str, List[str]], + data_type: Literal["image", "video"], + return_type: str = "numpy", + save_emb_path: str = None, + save_type: str = "h5py", + emb_key: str = "encoder_emb", + quant_emb_key: str = "encoder_quant_emb", + sample_index_key: str = "sample_indexs", + insert_name_to_key: bool = False, + overwrite: bool = False, + save_sample_index: bool = True, + input_rgb_order: str = "rgb", + **kwargs, + ) -> Union[np.ndarray, torch.tensor]: + if self.name is not None and insert_name_to_key: + emb_key = f"{self.name}_{emb_key}" + quant_emb_key = f"{self.name}_{quant_emb_key}" + sample_index_key = f"{self.name}_{sample_index_key}" + if save_emb_path is not None and os.path.exists(save_emb_path): + with h5py.File(save_emb_path, "r") as f: + if ( + not overwrite + and emb_key in f + and quant_emb_key in f + and sample_index_key in f + ): + return None + + if data_type == "image": + emb, quant_emb = self.extract_images( + data=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return emb, quant_emb + else: + raise NotImplementedError("save images emb") + elif data_type == "video": + sample_indexs, emb, quant_emb = self.extract_video( + video_dataset=data, + return_type=return_type, + input_rgb_order=input_rgb_order, + **kwargs, + ) + if save_emb_path is None: + return sample_indexs, emb, quant_emb + else: + if save_type == "h5py": + self.save_video_emb_with_h5py( + save_emb_path=save_emb_path, + emb=emb, + emb_key=emb_key, + quant_emb=quant_emb, + quant_emb_key=quant_emb_key, + sample_indexs=sample_indexs, + sample_index_key=sample_index_key, + save_sample_index=save_sample_index, + overwrite=overwrite, + ) + return sample_indexs, emb, quant_emb + else: + raise ValueError(f"only support save_type={save_type}") + + @staticmethod + def save_images_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "encoder_emb", + quant_emb: np.ndarray = None, + quant_emb_key: str = "encoder_quant_emb", + ) -> h5py.File: + save_value_with_h5py(save_emb_path, value=emb, key=emb_key) + save_value_with_h5py(save_emb_path, value=quant_emb, key=quant_emb_key) + + @staticmethod + def save_video_emb_with_h5py( + save_emb_path: str, + emb: np.ndarray = None, + emb_key: str = "encoder_emb", + quant_emb: np.ndarray = None, + quant_emb_key: str = "encoder_quant_emb", + sample_indexs: np.ndarray = None, + sample_index_key: str = "sample_indexs", + overwrite: bool = False, + save_sample_index: bool = True, + ) -> h5py.File: + # save_value_with_h5py(save_emb_path, value=emb, key=emb_key, overwrite=overwrite) + if save_sample_index: + save_value_with_h5py( + save_emb_path, + value=quant_emb, + key=quant_emb_key, + overwrite=overwrite, + dtype=np.float16, + ) + save_value_with_h5py( + save_emb_path, + value=sample_indexs, + key=sample_index_key, + overwrite=overwrite, + dtype=np.uint32, + ) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/README.md b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/README.md new file mode 100755 index 0000000000000000000000000000000000000000..e64286ab7e0ae47180052d2fa8581629769f41ad --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/README.md @@ -0,0 +1,41 @@ +# photoalbumn/video2music + +本项目为提交给vivo demo的视频和相册配乐中，召回音乐的代码。使用文澜图文匹配技术，视频配乐随机选取5帧图像，相册配乐使用相册中的所有图片，文本为音乐歌词。 +每张图片均召回100首歌曲，最后对这100首歌曲的score分数进行排序，输出最终的100首歌曲。热度版本即改变歌曲热度池子范围。 + + +# 使用 +### 搭建环境 + +``` +# 环境要求 +lmdb==0.99 +timm==0.4.12 +easydict==1.9 +pandas==1.2.4 +jsonlines==2.0.0 +tqdm==4.60.0 +torchvision==0.8.2 +numpy==1.20.2 +torch==1.7.1 +transformers==4.5.1 +msgpack_numpy==0.4.7.1 +msgpack_python==0.5.6 +Pillow==8.3.1 +PyYAML==5.4.1 +detectron2==0.3+cu102 +``` + +### 视频配乐 +``` +bash vivo_video2music.sh +``` + +### 相册配乐 +``` +bash vivo_photoalbumn2music.sh +``` + +### 注意 +代码需分成独立的3步走。首先提取歌曲歌词，提取完歌词后，提取歌曲和视频特征，最后才进行检索。 + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/README.md b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/README.md new file mode 100755 index 0000000000000000000000000000000000000000..4c46fb6c43ca05268499c7f0868263e65396c045 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/README.md @@ -0,0 +1,80 @@ +# Bottom Up Attention For Application + +This object detection tool implements from [bottom-up-attention](https://github.com/peteanderson80/bottom-up-attention) project and [bottom-up-attention.pytorch](https://github.com/MILVLG/bottom-up-attention.pytorch) project. This tool has been used in the application *AI's Imaginary World* for **BriVL**'s data preprocessing. + +**The environment of this repo is easier to build, for the dependency on the cython version in the original repo is fixed** + + + +## Requirements + +- [Python](https://www.python.org/downloads/) >= 3.6 +- [PyTorch](http://pytorch.org/) >= 1.4 +- [Cuda](https://developer.nvidia.com/cuda-toolkit) >= 9.2 and [cuDNN](https://developer.nvidia.com/cudnn) +- [Detectron2](https://github.com/facebookresearch/detectron2/releases/tag/v0.3) <= 0.3 + +**Important: The version of Detectron2 should be 0.3 or below.** + +**Install Pre-Built Detectron2 (Linux only)** + +Choose from this table to install [v0.3 (Nov 2020)](https://github.com/facebookresearch/detectron2/releases): + +
CUDA torch 1.7torch 1.6torch 1.5
11.0
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu110/torch1.7/index.html
+
10.2
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu102/torch1.7/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu102/torch1.6/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu102/torch1.5/index.html
+
10.1
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.7/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.6/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.5/index.html
+
9.2
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu92/torch1.7/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu92/torch1.6/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cu92/torch1.5/index.html
+
cpu
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cpu/torch1.7/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cpu/torch1.6/index.html
+
install 
python -m pip install detectron2 -f \
+  https://dl.fbaipublicfiles.com/detectron2/wheels/cpu/torch1.5/index.html
+
+ + + +*Anaconda is recommended.* + +## Download Model +Put the pre-trained model in ./weights. You can download the pre-trained object detection model from [here](https://drive.google.com/file/d/1oquCwDEvuJPeU7pyPg-Yudj5-8ZxtG0W/view?usp=sharing). +## Test BUA tool + +Test image has been saved in ./test_data, Test BUA tool with following command: + +``` +python3 bbox_extractor.py --img_path test_data/test.png --out_path test_data/test.npz +``` + + +## QR Code of AI's Imaginary World +*AI's Imaginary World* is developed based on the **BriVL** model, You can use the QR code below to experience [AI's Imaginary World](http://buling.wudaoai.cn/). + +![bling](./img/bling_300x300.jpeg) + +## More Resources + +[Source Code of BriVL 1.0](https://github.com/BAAI-WuDao/BriVL) + +[Model of BriVL 1.0\*](https://wudaoai.cn/model/detail/BriVL) + +[Online API of BriVL 1.0](https://github.com/chuhaojin/WenLan-api-document) + +[Online API of BriVL 2.0](https://wudaoai.cn/model/detail/BriVL) + +\* indicates an application is needed. diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..c275ac7898bfd1bf793f4502ef8c04d447926d98 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_extractor.py @@ -0,0 +1,113 @@ +# -*- coding:UTF8 -*- + +"""Image bounding-box extraction process.""" + +import os +import sys +import sys +import cv2 +import numpy as np +import glob + +import torch +from detectron2.checkpoint import DetectionCheckpointer +from detectron2.config import get_cfg +from detectron2.engine import default_setup +from detectron2.engine import DefaultTrainer +from detectron2.layers.nms import nms + +from .bbox_utils.extract_utils import get_image_blob +from .bbox_models import add_config +from .bbox_models.bua.box_regression import BUABoxes +from .bbox_models.bua import add_bottom_up_attention_config + +class BboxExtractor: + def __init__(self, cfg_file, gpu_id = 0): + + self.cfg_file = cfg_file + self.gpu_id = gpu_id + self.cfg = get_cfg() + add_bottom_up_attention_config(self.cfg, True) + self.cfg.merge_from_file(self.cfg_file) + self.cfg.freeze() + default_setup(self.cfg, None) + + self.bbox_extract_model = DefaultTrainer.build_model(self.cfg) +# self.bbox_extract_model.cuda(gpu_id) + bbox_extract_model_dict = self.bbox_extract_model.state_dict() + bbox_extract_checkpoint_dict = torch.load(self.cfg.MODEL.WEIGHTS, map_location=torch.device('cuda:0'))['model'] + bbox_extract_checkpoint_dict = {k:v for k, v in bbox_extract_checkpoint_dict.items() if k in bbox_extract_model_dict} + bbox_extract_model_dict.update(bbox_extract_checkpoint_dict) + self.bbox_extract_model.load_state_dict(bbox_extract_model_dict) + # self.bbox_extract_model = torch.nn.DataParallel(self.bbox_extract_model, device_ids=self.gpus) + self.bbox_extract_model.eval() + + def clean_bbox(self, dataset_dict, boxes, scores): + MIN_BOXES = self.cfg.MODEL.BUA.EXTRACTOR.MIN_BOXES + MAX_BOXES = self.cfg.MODEL.BUA.EXTRACTOR.MAX_BOXES + CONF_THRESH = self.cfg.MODEL.BUA.EXTRACTOR.CONF_THRESH + + scores = scores[0] + boxes = boxes[0] + num_classes = scores.shape[1] + boxes = BUABoxes(boxes.reshape(-1, 4)) + boxes.clip((dataset_dict['image'].shape[1]/dataset_dict['im_scale'], dataset_dict['image'].shape[2]/dataset_dict['im_scale'])) + boxes = boxes.tensor.view(-1, num_classes*4) # R x C x 4 + + cls_boxes = torch.zeros((boxes.shape[0], 4)) + for idx in range(boxes.shape[0]): + cls_idx = torch.argmax(scores[idx, 1:]) + 1 + cls_boxes[idx, :] = boxes[idx, cls_idx * 4:(cls_idx + 1) * 4] + + max_conf = torch.zeros((scores.shape[0])).to(scores.device) + for cls_ind in range(1, num_classes): + cls_scores = scores[:, cls_ind] + keep = nms(cls_boxes, cls_scores, 0.3) + max_conf[keep] = torch.where(cls_scores[keep] > max_conf[keep], + cls_scores[keep], + max_conf[keep]) + + keep_boxes = torch.argsort(max_conf, descending=True)[:MAX_BOXES] + image_bboxes = cls_boxes[keep_boxes] + + return image_bboxes + + def extract_bboxes(self, img_path): + if type(img_path)==str: + im = cv2.imread(img_path) + else: + im = img_path + if im is None: + print("img is None!") + return None + else: + dataset_dict = get_image_blob(im, self.cfg.MODEL.PIXEL_MEAN) + with torch.set_grad_enabled(False): + boxes, scores = self.bbox_extract_model([dataset_dict]) + boxes = [box.cpu() for box in boxes] + scores = [score.cpu() for score in scores] + boxes = self.clean_bbox(dataset_dict, boxes, scores) + + return boxes # boxes type tensor + +if __name__ == '__main__': + import argparse + parser = argparse.ArgumentParser() + parser.add_argument('--img_path', type=str, dest="img_path", default="/data1/sxhong/video_image") + parser.add_argument('--out_path', type=str, dest="output_file", default="./data/shuishoupai_bbox") + args = parser.parse_args() + image_paths = glob.glob(os.path.join(args.img_path, '*')) + + for image_path in image_paths: + save_file = os.path.join(args.output_file, image_path.split('/')[-1].split('.')[0] + '.npz') + + print(save_file) + abs_path = os.path.dirname(os.path.abspath(__file__)) + bbx_extr = BboxExtractor(os.path.join(abs_path, 'configs/bua-caffe/extract-bua-caffe-r101.yaml')) + bboxes = bbx_extr.extract_bboxes(image_path) + np.savez_compressed(save_file, bbox=bboxes) + print(code) + np_bbox = bboxes.numpy().astype(np.int32) +# print(np_bbox) + print(bboxes.shape) + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..09343694d2667db18606bc72604abcba8632ad83 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/__init__.py @@ -0,0 +1,9 @@ +from .bua import add_bottom_up_attention_config + +def add_config(args, cfg): + if args.mode == "caffe": + add_bottom_up_attention_config(cfg, True) + elif args.mode == "detectron2": + add_bottom_up_attention_config(cfg) + else: + raise Exception("detection model not supported: {}".format(args.model)) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..51b7d0db76ee4bf8c4f8e3e7fbbcd8341697ada3 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/__init__.py @@ -0,0 +1,5 @@ +from .config import add_bottom_up_attention_config +from .backbone import build_bua_resnet_backbone +from .rcnn import GeneralizedBUARCNN +from .roi_heads import BUACaffeRes5ROIHeads +from .rpn import StandardBUARPNHead, BUARPN diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/backbone.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/backbone.py new file mode 100755 index 0000000000000000000000000000000000000000..c535798f9af0af15ae06ff0ae30a498839d68787 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/backbone.py @@ -0,0 +1,276 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import fvcore.nn.weight_init as weight_init +from torch import nn +import torch.nn.functional as F + +from detectron2.layers import Conv2d, FrozenBatchNorm2d, get_norm, BatchNorm2d +from detectron2.modeling import BACKBONE_REGISTRY, ResNet, make_stage +from detectron2.modeling.backbone.resnet import BottleneckBlock, DeformBottleneckBlock, ResNetBlockBase + +from .layers.wrappers import Conv2dv2 + +__all__ = ["BUABasicStem", "BUABasicStemv2", "build_bua_resnet_backbone"] + +class BUABasicStem(nn.Module): + def __init__(self, in_channels=3, out_channels=64, norm="BN"): + """ + Args: + norm (str or callable): a callable that takes the number of + channels and return a `nn.Module`, or a pre-defined string + (one of {"FrozenBN", "BN", "GN"}). + """ + super().__init__() + self.conv1 = Conv2d( + in_channels, + out_channels, + kernel_size=7, + stride=2, + padding=3, + bias=False, + norm=get_norm(norm, out_channels), + ) + weight_init.c2_msra_fill(self.conv1) + + def forward(self, x): + x = self.conv1(x) + x = F.relu_(x) + x = F.max_pool2d(x, kernel_size=3, stride=2, padding=0, ceil_mode=True) + return x + + @property + def out_channels(self): + return self.conv1.out_channels + + @property + def stride(self): + return 4 # = stride 2 conv -> stride 2 max pool + +class BUABasicStemv2(nn.Module): + def __init__(self, in_channels=3, out_channels=64, norm="BN"): + """ + Args: + norm (str or callable): a callable that takes the number of + channels and return a `nn.Module`, or a pre-defined string + (one of {"FrozenBN", "BN", "GN"}). + """ + super().__init__() + self.norm = BatchNorm2d(in_channels, eps=2e-5) + self.conv1 = Conv2d( + in_channels, + out_channels, + kernel_size=7, + stride=2, + padding=3, + bias=False, + norm=BatchNorm2d(out_channels, eps=2e-5), + ) + # weight_init.c2_msra_fill(self.norm) + weight_init.c2_msra_fill(self.conv1) + + def forward(self, x): + x = self.norm(x) + x = self.conv1(x) + x = F.relu_(x) + x = F.max_pool2d(x, kernel_size=3, stride=2, padding=0, ceil_mode=True) + return x + + @property + def out_channels(self): + return self.conv1.out_channels + + @property + def stride(self): + return 4 # = stride 2 conv -> stride 2 max pool + +@BACKBONE_REGISTRY.register() +def build_bua_resnet_backbone(cfg, input_shape): + """ + Create a ResNet instance from config. + + Returns: + ResNet: a :class:`ResNet` instance. + """ + # need registration of new blocks/stems? + norm = cfg.MODEL.RESNETS.NORM + if cfg.MODEL.BUA.RESNET_VERSION == 2: + stem = BUABasicStemv2( + in_channels=input_shape.channels, + out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS, + ) + else: + stem = BUABasicStem( + in_channels=input_shape.channels, + out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS, + norm=norm, + ) + freeze_at = cfg.MODEL.BACKBONE.FREEZE_AT + + if freeze_at >= 1: + for p in stem.parameters(): + p.requires_grad = False + stem = FrozenBatchNorm2d.convert_frozen_batchnorm(stem) + + # fmt: off + out_features = cfg.MODEL.RESNETS.OUT_FEATURES + depth = cfg.MODEL.RESNETS.DEPTH + num_groups = cfg.MODEL.RESNETS.NUM_GROUPS + width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP + bottleneck_channels = num_groups * width_per_group + in_channels = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS + out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS + stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1 + res5_dilation = cfg.MODEL.RESNETS.RES5_DILATION + deform_on_per_stage = cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE + deform_modulated = cfg.MODEL.RESNETS.DEFORM_MODULATED + deform_num_groups = cfg.MODEL.RESNETS.DEFORM_NUM_GROUPS + # fmt: on + assert res5_dilation in {1, 2}, "res5_dilation cannot be {}.".format(res5_dilation) + + num_blocks_per_stage = {50: [3, 4, 6, 3], 101: [3, 4, 23, 3], 152: [3, 8, 36, 3]}[depth] + + stages = [] + + # Avoid creating variables without gradients + # It consumes extra memory and may cause allreduce to fail + out_stage_idx = [{"res2": 2, "res3": 3, "res4": 4, "res5": 5}[f] for f in out_features] + max_stage_idx = max(out_stage_idx) + for idx, stage_idx in enumerate(range(2, max_stage_idx + 1)): + dilation = res5_dilation if stage_idx == 5 else 1 + first_stride = 1 if idx == 0 or (stage_idx == 5 and dilation == 2) else 2 + stage_kargs = { + "num_blocks": num_blocks_per_stage[idx], + "first_stride": first_stride, + "in_channels": in_channels, + "bottleneck_channels": bottleneck_channels, + "out_channels": out_channels, + "num_groups": num_groups, + "norm": norm, + "stride_in_1x1": stride_in_1x1, + "dilation": dilation, + } + if deform_on_per_stage[idx]: + stage_kargs["block_class"] = DeformBottleneckBlock + stage_kargs["deform_modulated"] = deform_modulated + stage_kargs["deform_num_groups"] = deform_num_groups + else: + stage_kargs["block_class"] = BottleneckBlock if cfg.MODEL.BUA.RESNET_VERSION == 1 else BottleneckBlockv2 + blocks = make_stage(**stage_kargs) + in_channels = out_channels + out_channels *= 2 + bottleneck_channels *= 2 + + if freeze_at >= stage_idx: + for block in blocks: + block.freeze() + stages.append(blocks) + return ResNet(stem, stages, out_features=out_features) + +class BottleneckBlockv2(ResNetBlockBase): + def __init__( + self, + in_channels, + out_channels, + *, + bottleneck_channels, + stride=1, + num_groups=1, + norm="BN", + stride_in_1x1=False, + dilation=1, + ): + """ + Args: + norm (str or callable): a callable that takes the number of + channels and return a `nn.Module`, or a pre-defined string + (one of {"FrozenBN", "BN", "GN"}). + stride_in_1x1 (bool): when stride==2, whether to put stride in the + first 1x1 convolution or the bottleneck 3x3 convolution. + """ + super().__init__(in_channels, out_channels, stride) + + if in_channels != out_channels: + self.shortcut = Conv2dv2( + in_channels, + out_channels, + kernel_size=1, + stride=stride, + bias=False, + norm=None, + ) + else: + self.shortcut = None + + # The original MSRA ResNet models have stride in the first 1x1 conv + # The subsequent fb.torch.resnet and Caffe2 ResNe[X]t implementations have + # stride in the 3x3 conv + stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride) + + self.conv1 = Conv2dv2( + in_channels, + bottleneck_channels, + kernel_size=1, + stride=stride_1x1, + bias=False, + norm=None, + ) + + self.conv2 = Conv2dv2( + bottleneck_channels, + bottleneck_channels, + kernel_size=3, + stride=stride_3x3, + padding=1 * dilation, + bias=False, + groups=num_groups, + dilation=dilation, + norm=BatchNorm2d(bottleneck_channels, eps=2e-5), + activation=F.relu_, + ) + + self.conv3 = Conv2dv2( + bottleneck_channels, + out_channels, + kernel_size=1, + bias=False, + norm=BatchNorm2d(bottleneck_channels, eps=2e-5), + activation=F.relu_, + ) + + for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]: + if layer is not None: # shortcut can be None + weight_init.c2_msra_fill(layer) + + self.norm = BatchNorm2d(in_channels, eps=2e-5) + + # Zero-initialize the last normalization in each residual branch, + # so that at the beginning, the residual branch starts with zeros, + # and each residual block behaves like an identity. + # See Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour": + # "For BN layers, the learnable scaling coefficient γ is initialized + # to be 1, except for each residual block's last BN + # where γ is initialized to be 0." + + # nn.init.constant_(self.conv3.norm.weight, 0) + # TODO this somehow hurts performance when training GN models from scratch. + # Add it as an option when we need to use this code to train a backbone. + + def forward(self, x): + x_2 = self.norm(x) + x_2 = F.relu_(x_2) + + out = self.conv1(x_2) + # out = F.relu_(out) + + out = self.conv2(out) + # out = F.relu_(out) + + out = self.conv3(out) + + if self.shortcut is not None: + shortcut = self.shortcut(x_2) + else: + shortcut = x + + out += shortcut + # out = F.relu_(out) + return out \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/box_regression.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/box_regression.py new file mode 100755 index 0000000000000000000000000000000000000000..34fc16813be25ae25b40d80ec97b8030dc851e33 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/box_regression.py @@ -0,0 +1,190 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import math +import torch +from detectron2.structures import Boxes +from typing import List, Tuple, Union + +# Value for clamping large dw and dh predictions. The heuristic is that we clamp +# such that dw and dh are no larger than what would transform a 16px box into a +# 1000px box (based on a small anchor, 16px, and a typical image size, 1000px). +_DEFAULT_SCALE_CLAMP = math.log(1000.0 / 16) + + +__all__ = ["BUABoxes", "BUABox2BoxTransform"] + +class BUABoxes(Boxes): + """ + This structure stores a list of boxes as a Nx4 torch.Tensor. + It supports some common methods about boxes + (`area`, `clip`, `nonempty`, etc), + and also behaves like a Tensor + (support indexing, `to(device)`, `.device`, and iteration over all boxes) + + Attributes: + tensor: float matrix of Nx4. + """ + + BoxSizeType = Union[List[int], Tuple[int, int]] + def __init__(self, tensor: torch.Tensor): + super().__init__(tensor) + + def clip(self, box_size: BoxSizeType) -> None: + """ + NOTE: In order to be the same as bottom-up-attention network, we have + defined the new clip function. + + Clip (in place) the boxes by limiting x coordinates to the range [0, width] + and y coordinates to the range [0, height]. + + Args: + box_size (height, width): The clipping box's size. + """ + assert torch.isfinite(self.tensor).all(), "Box tensor contains infinite or NaN!" + TO_REMOVE = 1 + h, w = box_size + self.tensor[:, 0].clamp_(min=0, max=w - TO_REMOVE) + self.tensor[:, 1].clamp_(min=0, max=h - TO_REMOVE) + self.tensor[:, 2].clamp_(min=0, max=w - TO_REMOVE) + self.tensor[:, 3].clamp_(min=0, max=h - TO_REMOVE) + + def nonempty(self, threshold: int = 0) -> torch.Tensor: + """ + NOTE: In order to be the same as bottom-up-attention network, we have + defined the new nonempty function. + + Find boxes that are non-empty. + A box is considered empty, if either of its side is no larger than threshold. + + Returns: + Tensor: + a binary vector which represents whether each box is empty + (False) or non-empty (True). + """ + TO_REMOVE = 1 + box = self.tensor + widths = box[:, 2] - box[:, 0] + TO_REMOVE + heights = box[:, 3] - box[:, 1] + TO_REMOVE + keep = (widths > threshold) & (heights > threshold) + return keep + + def filter_boxes(self): + box = self.tensor + keep = (box[:, 3] > box[:, 1]) & (box[:, 2] > box[:, 0]) + return keep + + def __getitem__(self, item: Union[int, slice, torch.BoolTensor]) -> "Boxes": + """ + Returns: + BUABoxes: Create a new :class:`BUABoxes` by indexing. + + The following usage are allowed: + 1. `new_boxes = boxes[3]`: return a `Boxes` which contains only one box. + 2. `new_boxes = boxes[2:10]`: return a slice of boxes. + 3. `new_boxes = boxes[vector]`, where vector is a torch.BoolTensor + with `length = len(boxes)`. Nonzero elements in the vector will be selected. + + Note that the returned Boxes might share storage with this Boxes, + subject to Pytorch's indexing semantics. + """ + if isinstance(item, int): + return BUABoxes(self.tensor[item].view(1, -1)) + b = self.tensor[item] + assert b.dim() == 2, "Indexing on Boxes with {} failed to return a matrix!".format(item) + return BUABoxes(b) + +class BUABox2BoxTransform(object): + """ + The box-to-box transform defined in R-CNN. The transformation is parameterized + by 4 deltas: (dx, dy, dw, dh). The transformation scales the box's width and height + by exp(dw), exp(dh) and shifts a box's center by the offset (dx * width, dy * height). + """ + + def __init__(self, weights, scale_clamp=_DEFAULT_SCALE_CLAMP): + """ + Args: + weights (4-element tuple): Scaling factors that are applied to the + (dx, dy, dw, dh) deltas. In Fast R-CNN, these were originally set + such that the deltas have unit variance; now they are treated as + hyperparameters of the system. + scale_clamp (float): When predicting deltas, the predicted box scaling + factors (dw and dh) are clamped such that they are <= scale_clamp. + """ + self.weights = weights + self.scale_clamp = scale_clamp + + def get_deltas(self, src_boxes, target_boxes): + """ + Get box regression transformation deltas (dx, dy, dw, dh) that can be used + to transform the `src_boxes` into the `target_boxes`. That is, the relation + ``target_boxes == self.apply_deltas(deltas, src_boxes)`` is true (unless + any delta is too large and is clamped). + + Args: + src_boxes (Tensor): source boxes, e.g., object proposals + target_boxes (Tensor): target of the transformation, e.g., ground-truth + boxes. + """ + assert isinstance(src_boxes, torch.Tensor), type(src_boxes) + assert isinstance(target_boxes, torch.Tensor), type(target_boxes) + + TO_REMOVE = 1 # TODO remove + src_widths = src_boxes[:, 2] - src_boxes[:, 0] + TO_REMOVE + src_heights = src_boxes[:, 3] - src_boxes[:, 1] + TO_REMOVE + src_ctr_x = src_boxes[:, 0] + 0.5 * src_widths + src_ctr_y = src_boxes[:, 1] + 0.5 * src_heights + + target_widths = target_boxes[:, 2] - target_boxes[:, 0] + TO_REMOVE + target_heights = target_boxes[:, 3] - target_boxes[:, 1] + TO_REMOVE + target_ctr_x = target_boxes[:, 0] + 0.5 * target_widths + target_ctr_y = target_boxes[:, 1] + 0.5 * target_heights + + wx, wy, ww, wh = self.weights + dx = wx * (target_ctr_x - src_ctr_x) / src_widths + dy = wy * (target_ctr_y - src_ctr_y) / src_heights + dw = ww * torch.log(target_widths / src_widths) + dh = wh * torch.log(target_heights / src_heights) + + deltas = torch.stack((dx, dy, dw, dh), dim=1) + assert (src_widths > 0).all().item(), "Input boxes to Box2BoxTransform are not valid!" + return deltas + + def apply_deltas(self, deltas, boxes): + """ + Apply transformation `deltas` (dx, dy, dw, dh) to `boxes`. + + Args: + deltas (Tensor): transformation deltas of shape (N, k*4), where k >= 1. + deltas[i] represents k potentially different class-specific + box transformations for the single box boxes[i]. + boxes (Tensor): boxes to transform, of shape (N, 4) + """ + assert torch.isfinite(deltas).all().item(), "Box regression deltas become infinite or NaN!" + boxes = boxes.to(deltas.dtype) + + TO_REMOVE = 1 # TODO remove + widths = boxes[:, 2] - boxes[:, 0] + TO_REMOVE + heights = boxes[:, 3] - boxes[:, 1] + TO_REMOVE + ctr_x = boxes[:, 0] + 0.5 * widths + ctr_y = boxes[:, 1] + 0.5 * heights + + wx, wy, ww, wh = self.weights + dx = deltas[:, 0::4] / wx + dy = deltas[:, 1::4] / wy + dw = deltas[:, 2::4] / ww + dh = deltas[:, 3::4] / wh + + # Prevent sending too large values into torch.exp() + dw = torch.clamp(dw, max=self.scale_clamp) + dh = torch.clamp(dh, max=self.scale_clamp) + + pred_ctr_x = dx * widths[:, None] + ctr_x[:, None] + pred_ctr_y = dy * heights[:, None] + ctr_y[:, None] + pred_w = torch.exp(dw) * widths[:, None] + pred_h = torch.exp(dh) * heights[:, None] + + pred_boxes = torch.zeros_like(deltas) + pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w # x1 + pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h # y1 + pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w # x2 + pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h # y2 + return pred_boxes \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/config.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/config.py new file mode 100755 index 0000000000000000000000000000000000000000..4852d4bd2de4e003461779fe0e01d83c17854321 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/config.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +from detectron2.config import CfgNode as CN + + +def add_bottom_up_attention_config(cfg, caffe=False): + """ + Add config for tridentnet. + """ + _C = cfg + + _C.MODEL.BUA = CN() + _C.MODEL.BUA.CAFFE = caffe + _C.MODEL.BUA.RESNET_VERSION = 1 + _C.MODEL.BUA.ATTRIBUTE_ON = False + _C.MODEL.BUA.EXTRACT_FEATS = False + + _C.MODEL.BUA.RPN = CN() + # out_channels of conv for bottom-up-attentions RPN. + _C.MODEL.BUA.RPN.CONV_OUT_CHANNELS = 512 + + _C.MODEL.BUA.EXTRACTOR = CN() + + # EXTRACTOR.MODE {1: extract roi features, 2: extract bbox only ,3: extract roi features by gt_bbox} + _C.MODEL.BUA.EXTRACTOR.MODE = 2 + + # config of postprocessing in extractor + _C.MODEL.BUA.EXTRACTOR.MIN_BOXES = 10 + _C.MODEL.BUA.EXTRACTOR.MAX_BOXES = 100 + _C.MODEL.BUA.EXTRACTOR.CONF_THRESH = 0.2 + _C.MODEL.BUA.EXTRACTOR.OUTPUT_DIR = ".output/" + + _C.MODEL.BUA.ATTRIBUTE = CN() + _C.MODEL.BUA.ATTRIBUTE.NUM_CLASSES = 401 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/fast_rcnn.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/fast_rcnn.py new file mode 100755 index 0000000000000000000000000000000000000000..a9b9d74aac8296e4b6b190d064d82790ca1716a9 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/fast_rcnn.py @@ -0,0 +1,594 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import logging +import numpy as np +import torch +from fvcore.nn import smooth_l1_loss +from torch import nn +from torch.nn import functional as F + +from detectron2.layers import cat +from detectron2.structures import Instances +from detectron2.utils.events import get_event_storage +from detectron2.modeling.roi_heads import select_foreground_proposals +from detectron2.modeling.roi_heads.fast_rcnn import fast_rcnn_inference, fast_rcnn_inference_single_image, FastRCNNOutputLayers + +from detectron2.layers.nms import batched_nms +from .box_regression import BUABoxes + +logger = logging.getLogger(__name__) + +""" +Shape shorthand in this module: + + N: number of images in the minibatch + R: number of ROIs, combined over all images, in the minibatch + Ri: number of ROIs in image i + K: number of foreground classes. E.g.,there are 80 foreground classes in COCO. + +Naming convention: + + deltas: refers to the 4-d (dx, dy, dw, dh) deltas that parameterize the box2box + transform (see :class:`box_regression.Box2BoxTransform`). + + pred_class_logits: predicted class scores in [-inf, +inf]; use + softmax(pred_class_logits) to estimate P(class). + + gt_classes: ground-truth classification labels in [0, K], where [0, K) represent + foreground object classes and K represents the background class. + + pred_proposal_deltas: predicted box2box transform deltas for transforming proposals + to detection box predictions. + + gt_proposal_deltas: ground-truth box2box transform deltas +""" + +class BUACaffeFastRCNNOutputs(object): + """ + A class that stores information about outputs of a Fast R-CNN head. + """ + + def __init__( + self, box2box_transform, pred_class_logits, pred_proposal_deltas, proposals, smooth_l1_beta, image_scales, attr_on=False + ): + """ + Args: + box2box_transform (Box2BoxTransform/Box2BoxTransformRotated): + box2box transform instance for proposal-to-detection transformations. + pred_class_logits (Tensor): A tensor of shape (R, K + 1) storing the predicted class + logits for all R predicted object instances. + Each row corresponds to a predicted object instance. + pred_proposal_deltas (Tensor): A tensor of shape (R, K * B) or (R, B) for + class-specific or class-agnostic regression. It stores the predicted deltas that + transform proposals into final box detections. + B is the box dimension (4 or 5). + When B is 4, each row is [dx, dy, dw, dh (, ....)]. + When B is 5, each row is [dx, dy, dw, dh, da (, ....)]. + proposals (list[Instances]): A list of N Instances, where Instances i stores the + proposals for image i, in the field "proposal_boxes". + When training, each Instances must have ground-truth labels + stored in the field "gt_classes" and "gt_boxes". + smooth_l1_beta (float): The transition point between L1 and L2 loss in + the smooth L1 loss function. When set to 0, the loss becomes L1. When + set to +inf, the loss becomes constant 0. + """ + self.box2box_transform = box2box_transform + self.num_preds_per_image = [len(p) for p in proposals] + self.pred_class_logits = pred_class_logits + self.pred_proposal_deltas = pred_proposal_deltas + self.smooth_l1_beta = smooth_l1_beta + self.image_scales = image_scales + self.attr_on = attr_on + + box_type = type(proposals[0].proposal_boxes) + # cat(..., dim=0) concatenates over all images in the batch + self.proposals = box_type.cat([p.proposal_boxes for p in proposals]) + assert not self.proposals.tensor.requires_grad, "Proposals should not require gradients!" + self.image_shapes = [x.image_size for x in proposals] + + # The following fields should exist only when training. + if proposals[0].has("gt_boxes"): + self.gt_boxes = box_type.cat([p.gt_boxes for p in proposals]) + assert proposals[0].has("gt_classes") + self.gt_classes = cat([p.gt_classes for p in proposals], dim=0) + + def fast_rcnn_inference(self, boxes, scores, image_shapes, image_scales, score_thresh, nms_thresh, topk_per_image): + """ + Call `fast_rcnn_inference_single_image` for all images. + + Args: + boxes (list[Tensor]): A list of Tensors of predicted class-specific or class-agnostic + boxes for each image. Element i has shape (Ri, K * 4) if doing + class-specific regression, or (Ri, 4) if doing class-agnostic + regression, where Ri is the number of predicted objects for image i. + This is compatible with the output of :meth:`FastRCNNOutputs.predict_boxes`. + scores (list[Tensor]): A list of Tensors of predicted class scores for each image. + Element i has shape (Ri, K + 1), where Ri is the number of predicted objects + for image i. Compatible with the output of :meth:`FastRCNNOutputs.predict_probs`. + image_shapes (list[tuple]): A list of (width, height) tuples for each image in the batch. + score_thresh (float): Only return detections with a confidence score exceeding this + threshold. + nms_thresh (float): The threshold to use for box non-maximum suppression. Value in [0, 1]. + topk_per_image (int): The number of top scoring detections to return. Set < 0 to return + all detections. + + Returns: + instances: (list[Instances]): A list of N instances, one for each image in the batch, + that stores the topk most confidence detections. + kept_indices: (list[Tensor]): A list of 1D tensor of length of N, each element indicates + the corresponding boxes/scores index in [0, Ri) from the input, for image i. + """ + result_per_image = [ + self.fast_rcnn_inference_single_image( + boxes_per_image, scores_per_image, image_shape, image_scale, score_thresh, nms_thresh, topk_per_image + ) + for scores_per_image, boxes_per_image, image_shape, image_scale in zip(scores, boxes, image_shapes, image_scales) + ] + return tuple(list(x) for x in zip(*result_per_image)) + + def fast_rcnn_inference_single_image( + self, boxes, scores, image_shape, image_scale, score_thresh, nms_thresh, topk_per_image + ): + """ + Single-image inference. Return bounding-box detection results by thresholding + on scores and applying non-maximum suppression (NMS). + + Args: + Same as `fast_rcnn_inference`, but with boxes, scores, and image shapes + per image. + + Returns: + Same as `fast_rcnn_inference`, but for only one image. + """ + scores = scores[:, 1:] + boxes = boxes[:, 4:] + num_bbox_reg_classes = boxes.shape[1] // 4 + # Convert to Boxes to use the `clip` function ... + boxes = BUABoxes(boxes.reshape(-1, 4)) + boxes.clip((image_shape[0]/image_scale, image_shape[1]/image_scale)) + boxes = boxes.tensor.view(-1, num_bbox_reg_classes, 4) # R x C x 4 + + # Filter results based on detection scores + filter_mask = scores > score_thresh # R x K + # R' x 2. First column contains indices of the R predictions; + # Second column contains indices of classes. + filter_inds = filter_mask.nonzero() + if num_bbox_reg_classes == 1: + boxes = boxes[filter_inds[:, 0], 0] + else: + boxes = boxes[filter_mask] + scores = scores[filter_mask] + + # Apply per-class NMS + keep = batched_nms(boxes, scores, filter_inds[:, 1], nms_thresh) + if topk_per_image >= 0: + keep = keep[:topk_per_image] + boxes, scores, filter_inds = boxes[keep], scores[keep], filter_inds[keep] + + result = Instances(image_shape) + result.pred_boxes = BUABoxes(boxes) + result.scores = scores + result.pred_classes = filter_inds[:, 1] + return result, filter_inds[:, 0] + + def predict_boxes(self): + """ + Returns: + list[Tensor]: A list of Tensors of predicted class-specific or class-agnostic boxes + for each image. Element i has shape (Ri, K * B) or (Ri, B), where Ri is + the number of predicted objects for image i and B is the box dimension (4 or 5) + """ + # Always use 1 image per worker during inference since this is the + # standard when reporting inference time in papers. + self.proposals.scale(1.0/self.image_scales[0], 1.0/self.image_scales[0]) + num_pred = len(self.proposals) + B = self.proposals.tensor.shape[1] + K = self.pred_proposal_deltas.shape[1] // B + boxes = self.box2box_transform.apply_deltas( + self.pred_proposal_deltas, + self.proposals.tensor, + ) + return boxes.view(num_pred, K * B).split(self.num_preds_per_image, dim=0) + + def predict_probs(self): + """ + Returns: + list[Tensor]: A list of Tensors of predicted class probabilities for each image. + Element i has shape (Ri, K + 1), where Ri is the number of predicted objects + for image i. + """ + probs = F.softmax(self.pred_class_logits, dim=-1) + return probs.split(self.num_preds_per_image, dim=0) + + def inference(self, score_thresh, nms_thresh, topk_per_image): + """ + Args: + score_thresh (float): same as fast_rcnn_inference. + nms_thresh (float): same as fast_rcnn_inference. + topk_per_image (int): same as fast_rcnn_inference. + Returns: + list[Instances]: same as fast_rcnn_inference. + list[Tensor]: same as fast_rcnn_inference. + """ + boxes = self.predict_boxes() + scores = self.predict_probs() + image_shapes = self.image_shapes + image_scales = self.image_scales + + return self.fast_rcnn_inference( + boxes, scores, image_shapes, image_scales, score_thresh, nms_thresh, topk_per_image + ) + +class BUACaffeFastRCNNOutputLayers(nn.Module): + """ + Two linear layers for predicting Fast R-CNN outputs: + (1) proposal-to-detection box regression deltas + (2) classification scores + """ + + def __init__(self, input_size, num_classes, cls_agnostic_bbox_reg, box_dim=4, attr_on=False, num_attr_classes=401): + """ + Args: + input_size (int): channels, or (channels, height, width) + num_classes (int): number of foreground classes + cls_agnostic_bbox_reg (bool): whether to use class agnostic for bbox regression + box_dim (int): the dimension of bounding boxes. + Example box dimensions: 4 for regular XYXY boxes and 5 for rotated XYWHA boxes + """ + super(BUACaffeFastRCNNOutputLayers, self).__init__() + + if not isinstance(input_size, int): + input_size = np.prod(input_size) + self.attr_on = attr_on + + # The prediction layer for num_classes foreground classes and one background class + # (hence + 1) + self.cls_score = nn.Linear(input_size, num_classes) + num_bbox_reg_classes = 1 if cls_agnostic_bbox_reg else num_classes + self.bbox_pred = nn.Linear(input_size, num_bbox_reg_classes * box_dim) + + nn.init.normal_(self.cls_score.weight, std=0.01) + nn.init.normal_(self.bbox_pred.weight, std=0.001) + for l in [self.cls_score, self.bbox_pred]: + nn.init.constant_(l.bias, 0) + + if self.attr_on: + self.cls_embed = nn.Embedding(num_classes, 256) + self.attr_linear1 = nn.Linear(input_size + 256, 512) + self.attr_linear2 = nn.Linear(512, num_attr_classes) + + nn.init.normal_(self.cls_embed.weight, std=0.01) + nn.init.normal_(self.attr_linear1.weight, std=0.01) + nn.init.normal_(self.attr_linear2.weight, std=0.01) + nn.init.constant_(self.attr_linear1.bias, 0) + nn.init.constant_(self.attr_linear2.bias, 0) + + def forward(self, x, proposal_boxes=None): + if x.dim() > 2: + x = torch.flatten(x, start_dim=1) + scores = self.cls_score(x) + proposal_deltas = self.bbox_pred(x) + + if self.attr_on: + + # get labels and indices of proposals with foreground + all_labels = torch.argmax(scores, dim=1) + + # get embeddings of indices using gt cls labels + cls_embed_out = self.cls_embed(all_labels) + + # concat with fc7 feats + concat_attr = cat([x, cls_embed_out], dim=1) + + # pass through attr head layers + fc_attr = self.attr_linear1(concat_attr) + attr_score = F.softmax(self.attr_linear2(F.relu(fc_attr)), dim=-1) + return scores, proposal_deltas, attr_score + + return scores, proposal_deltas + +class BUADetection2FastRCNNOutputs(FastRCNNOutputLayers): + """ + A class that stores information about outputs of a Fast R-CNN head. + """ + + def __init__( + + self, box2box_transform, pred_class_logits, pred_proposal_deltas, proposals, smooth_l1_beta, attr_on=False, pred_attribute_logits=None, num_attr_classes=400, gt_attributes=None + ): + """ + Args: + box2box_transform (Box2BoxTransform/Box2BoxTransformRotated): + box2box transform instance for proposal-to-detection transformations. + pred_class_logits (Tensor): A tensor of shape (R, K + 1) storing the predicted class + logits for all R predicted object instances. + Each row corresponds to a predicted object instance. + pred_proposal_deltas (Tensor): A tensor of shape (R, K * B) or (R, B) for + class-specific or class-agnostic regression. It stores the predicted deltas that + transform proposals into final box detections. + B is the box dimension (4 or 5). + When B is 4, each row is [dx, dy, dw, dh (, ....)]. + When B is 5, each row is [dx, dy, dw, dh, da (, ....)]. + pred_attribute_logits (Tensor:) A tensor of shape (R, C) storing the predicted attribute + logits for all R predicted object instances. + proposals (list[Instances]): A list of N Instances, where Instances i stores the + proposals for image i, in the field "proposal_boxes". + When training, each Instances must have ground-truth labels + stored in the field "gt_classes" and "gt_boxes". + smooth_l1_beta (float): The transition point between L1 and L2 loss in + the smooth L1 loss function. When set to 0, the loss becomes L1. When + set to +inf, the loss becomes constant 0. + """ + self.attr_on = attr_on + self.box2box_transform = box2box_transform + self.num_preds_per_image = [len(p) for p in proposals] + self.pred_class_logits = pred_class_logits + self.pred_proposal_deltas = pred_proposal_deltas + + if self.attr_on: + self.pred_attribute_logits = pred_attribute_logits + self.gt_attributes = gt_attributes + self.smooth_l1_beta = smooth_l1_beta + + box_type = type(proposals[0].proposal_boxes) + # cat(..., dim=0) concatenates over all images in the batch + self.proposals = box_type.cat([p.proposal_boxes for p in proposals]) + assert not self.proposals.tensor.requires_grad, "Proposals should not require gradients!" + self.image_shapes = [x.image_size for x in proposals] + self.num_attr_classes = num_attr_classes + + # The following fields should exist only when training. + if proposals[0].has("gt_boxes"): + self.gt_boxes = box_type.cat([p.gt_boxes for p in proposals]) + assert proposals[0].has("gt_classes") + self.gt_classes = cat([p.gt_classes for p in proposals], dim=0) + + def _log_accuracy(self): + """ + Log the accuracy metrics to EventStorage. + """ + num_instances = self.gt_classes.numel() + pred_classes = self.pred_class_logits.argmax(dim=1) + bg_class_ind = self.pred_class_logits.shape[1] - 1 + + fg_inds = (self.gt_classes >= 0) & (self.gt_classes < bg_class_ind) + num_fg = fg_inds.nonzero().numel() + fg_gt_classes = self.gt_classes[fg_inds] + fg_pred_classes = pred_classes[fg_inds] + + num_false_negative = (fg_pred_classes == bg_class_ind).nonzero().numel() + num_accurate = (pred_classes == self.gt_classes).nonzero().numel() + fg_num_accurate = (fg_pred_classes == fg_gt_classes).nonzero().numel() + + storage = get_event_storage() + storage.put_scalar("fast_rcnn/cls_accuracy", num_accurate / num_instances) + if num_fg > 0: + storage.put_scalar("fast_rcnn/fg_cls_accuracy", fg_num_accurate / num_fg) + storage.put_scalar("fast_rcnn/false_negative", num_false_negative / num_fg) + + def softmax_cross_entropy_loss(self): + """ + Compute the softmax cross entropy loss for box classification. + + Returns: + scalar Tensor + """ + self._log_accuracy() + return F.cross_entropy(self.pred_class_logits, self.gt_classes, reduction="mean") + + def smooth_l1_loss(self): + """ + Compute the smooth L1 loss for box regression. + + Returns: + scalar Tensor + """ + gt_proposal_deltas = self.box2box_transform.get_deltas( + self.proposals.tensor, self.gt_boxes.tensor + ) + box_dim = gt_proposal_deltas.size(1) # 4 or 5 + cls_agnostic_bbox_reg = self.pred_proposal_deltas.size(1) == box_dim + device = self.pred_proposal_deltas.device + + bg_class_ind = self.pred_class_logits.shape[1] - 1 + + # Box delta loss is only computed between the prediction for the gt class k + # (if 0 <= k < bg_class_ind) and the target; there is no loss defined on predictions + # for non-gt classes and background. + # Empty fg_inds produces a valid loss of zero as long as the size_average + # arg to smooth_l1_loss is False (otherwise it uses torch.mean internally + # and would produce a nan loss). + fg_inds = torch.nonzero((self.gt_classes >= 0) & (self.gt_classes < bg_class_ind)).squeeze( + 1 + ) + if cls_agnostic_bbox_reg: + # pred_proposal_deltas only corresponds to foreground class for agnostic + gt_class_cols = torch.arange(box_dim, device=device) + else: + fg_gt_classes = self.gt_classes[fg_inds] + # pred_proposal_deltas for class k are located in columns [b * k : b * k + b], + # where b is the dimension of box representation (4 or 5) + # Note that compared to Detectron1, + # we do not perform bounding box regression for background classes. + gt_class_cols = box_dim * fg_gt_classes[:, None] + torch.arange(box_dim, device=device) + + loss_box_reg = smooth_l1_loss( + self.pred_proposal_deltas[fg_inds[:, None], gt_class_cols], + gt_proposal_deltas[fg_inds], + self.smooth_l1_beta, + reduction="sum", + ) + # The loss is normalized using the total number of regions (R), not the number + # of foreground regions even though the box regression loss is only defined on + # foreground regions. Why? Because doing so gives equal training influence to + # each foreground example. To see how, consider two different minibatches: + # (1) Contains a single foreground region + # (2) Contains 100 foreground regions + # If we normalize by the number of foreground regions, the single example in + # minibatch (1) will be given 100 times as much influence as each foreground + # example in minibatch (2). Normalizing by the total number of regions, R, + # means that the single example in minibatch (1) and each of the 100 examples + # in minibatch (2) are given equal influence. + loss_box_reg = loss_box_reg / self.gt_classes.numel() + return loss_box_reg + + def attribute_loss(self): + fg_gt_attributes = self.gt_attributes + n_boxes = self.pred_attribute_logits.shape[0] + self.pred_attribute_logits = self.pred_attribute_logits.unsqueeze(1) + self.pred_attribute_logits = self.pred_attribute_logits.expand(n_boxes, 16, self.num_attr_classes).contiguous().view(-1, self.num_attr_classes) + + inv_per_box_weights = ( + (fg_gt_attributes >= 0).sum(dim=1).repeat(16, 1).transpose(0, 1).flatten() + ) + per_box_weights = inv_per_box_weights.float().reciprocal() + per_box_weights[per_box_weights > 1] = 0.0 + + fg_gt_attributes = fg_gt_attributes.view(-1) + attributes_loss = 0.5 * F.cross_entropy( + self.pred_attribute_logits, fg_gt_attributes, reduction="none", ignore_index=-1 + ) + + attributes_loss = (attributes_loss * per_box_weights).view(n_boxes, -1).sum(dim=1) + + n_valid_boxes = len(attributes_loss.nonzero()) + + if n_valid_boxes > 0: + attributes_loss = (attributes_loss / n_valid_boxes).sum() + else: + attributes_loss = (attributes_loss * 0.0).sum() + return attributes_loss + + def losses(self): + """ + Compute the default losses for box head in Fast(er) R-CNN, + with softmax cross entropy loss and smooth L1 loss. + + Returns: + A dict of losses (scalar tensors) containing keys "loss_cls" and "loss_box_reg". + """ + return { + "loss_cls": self.softmax_cross_entropy_loss(), + "loss_box_reg": self.smooth_l1_loss(), + "loss_attr": self.attribute_loss() if self.attr_on else 0., + } + + def predict_boxes(self): + """ + Returns: + list[Tensor]: A list of Tensors of predicted class-specific or class-agnostic boxes + for each image. Element i has shape (Ri, K * B) or (Ri, B), where Ri is + the number of predicted objects for image i and B is the box dimension (4 or 5) + """ + num_pred = len(self.proposals) + B = self.proposals.tensor.shape[1] + K = self.pred_proposal_deltas.shape[1] // B + boxes = self.box2box_transform.apply_deltas( + self.pred_proposal_deltas.view(num_pred * K, B), + self.proposals.tensor.unsqueeze(1).expand(num_pred, K, B).reshape(-1, B), + ) + return boxes.view(num_pred, K * B).split(self.num_preds_per_image, dim=0) + + def predict_probs(self): + """ + Returns: + list[Tensor]: A list of Tensors of predicted class probabilities for each image. + Element i has shape (Ri, K + 1), where Ri is the number of predicted objects + for image i. + """ + probs = F.softmax(self.pred_class_logits, dim=-1) + return probs.split(self.num_preds_per_image, dim=0) + + def inference(self, score_thresh, nms_thresh, topk_per_image): + """ + Args: + score_thresh (float): same as fast_rcnn_inference. + nms_thresh (float): same as fast_rcnn_inference. + topk_per_image (int): same as fast_rcnn_inference. + Returns: + list[Instances]: same as fast_rcnn_inference. + list[Tensor]: same as fast_rcnn_inference. + """ + boxes = self.predict_boxes() + scores = self.predict_probs() + image_shapes = self.image_shapes + + return fast_rcnn_inference( + boxes, scores, image_shapes, score_thresh, nms_thresh, topk_per_image + ) + +class BUADetectron2FastRCNNOutputLayers(nn.Module): + """ + Two linear layers for predicting Fast R-CNN outputs: + (1) proposal-to-detection box regression deltas + (2) classification scores + """ + + def __init__(self, input_size, num_classes, cls_agnostic_bbox_reg, box_dim=4, attr_on=False, num_attr_classes=400): + """ + Args: + input_size (int): channels, or (channels, height, width) + num_classes (int): number of foreground classes + cls_agnostic_bbox_reg (bool): whether to use class agnostic for bbox regression + box_dim (int): the dimension of bounding boxes. + Example box dimensions: 4 for regular XYXY boxes and 5 for rotated XYWHA boxes + """ + super(BUADetectron2FastRCNNOutputLayers, self).__init__() + self.attr_on = attr_on + self.num_classes = num_classes + self.num_attr_classes = num_attr_classes + + if not isinstance(input_size, int): + input_size = np.prod(input_size) + + # The prediction layer for num_classes foreground classes and one background class + # (hence + 1) + self.cls_score = nn.Linear(input_size, num_classes + 1) + num_bbox_reg_classes = 1 if cls_agnostic_bbox_reg else num_classes + self.bbox_pred = nn.Linear(input_size, num_bbox_reg_classes * box_dim) + + nn.init.normal_(self.cls_score.weight, std=0.01) + nn.init.normal_(self.bbox_pred.weight, std=0.001) + for l in [self.cls_score, self.bbox_pred]: + nn.init.constant_(l.bias, 0) + + if self.attr_on: + self.cls_embed = nn.Embedding(num_classes+1, 256) + self.attr_linear1 = nn.Linear(input_size + 256, 512) + self.attr_linear2 = nn.Linear(512, num_attr_classes) + + # nn.init.normal_(self.cls_embed.weight, std=0.01) + nn.init.normal_(self.attr_linear1.weight, std=0.01) + nn.init.normal_(self.attr_linear2.weight, std=0.01) + nn.init.constant_(self.attr_linear1.bias, 0) + nn.init.constant_(self.attr_linear2.bias, 0) + + def forward(self, x, proposal_boxes=None): + if x.dim() > 2: + x = torch.flatten(x, start_dim=1) + scores = self.cls_score(x) + proposal_deltas = self.bbox_pred(x) + + if self.attr_on: + if self.training: + assert proposal_boxes is not None, "Proposals are None while attr=True" + proposals, fg_selection_atrributes = select_foreground_proposals(proposal_boxes, self.num_classes) + attribute_features = x[torch.cat(fg_selection_atrributes, dim=0)] + cls_labels = torch.cat([prop.gt_classes for prop in proposals]) + + else: + # get labels and indices of proposals with foreground + cls_labels = torch.argmax(scores, dim=1) + attribute_features = x + + # get embeddings of indices using gt cls labels + cls_embed_out = self.cls_embed(cls_labels) + + # concat with fc7 feats + concat_attr = cat([attribute_features, cls_embed_out], dim=1) + + # pass through attr head layers + fc_attr = self.attr_linear1(concat_attr) + attr_score = self.attr_linear2(F.relu(fc_attr)) + return scores, proposal_deltas, attr_score, cat([p.gt_attributes for p in proposals], dim=0) if self.training else None + + return scores, proposal_deltas diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..de1d0d959e1c3026914fcde4b9b314da04d084fd --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/__init__.py @@ -0,0 +1,4 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +from .nms import SwapAlign2Nat, swap_align2nat + +__all__ = [k for k in globals().keys() if not k.startswith("_")] \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.cu b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.cu new file mode 100755 index 0000000000000000000000000000000000000000..833d8523a5809d99a1078a144a384c864a9d8df9 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.cu @@ -0,0 +1,131 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include +#include + +#include +#include + +#include +#include + +int const threadsPerBlock = sizeof(unsigned long long) * 8; + +__device__ inline float devIoU(float const * const a, float const * const b) { + float left = max(a[0], b[0]), right = min(a[2], b[2]); + float top = max(a[1], b[1]), bottom = min(a[3], b[3]); + float width = max(right - left + 1, 0.f), height = max(bottom - top + 1, 0.f); + float interS = width * height; + float Sa = (a[2] - a[0] + 1) * (a[3] - a[1] + 1); + float Sb = (b[2] - b[0] + 1) * (b[3] - b[1] + 1); + return interS / (Sa + Sb - interS); +} + +__global__ void nms_kernel(const int n_boxes, const float nms_overlap_thresh, + const float *dev_boxes, unsigned long long *dev_mask) { + const int row_start = blockIdx.y; + const int col_start = blockIdx.x; + + // if (row_start > col_start) return; + + const int row_size = + min(n_boxes - row_start * threadsPerBlock, threadsPerBlock); + const int col_size = + min(n_boxes - col_start * threadsPerBlock, threadsPerBlock); + + __shared__ float block_boxes[threadsPerBlock * 5]; + if (threadIdx.x < col_size) { + block_boxes[threadIdx.x * 5 + 0] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 0]; + block_boxes[threadIdx.x * 5 + 1] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 1]; + block_boxes[threadIdx.x * 5 + 2] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 2]; + block_boxes[threadIdx.x * 5 + 3] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 3]; + block_boxes[threadIdx.x * 5 + 4] = + dev_boxes[(threadsPerBlock * col_start + threadIdx.x) * 5 + 4]; + } + __syncthreads(); + + if (threadIdx.x < row_size) { + const int cur_box_idx = threadsPerBlock * row_start + threadIdx.x; + const float *cur_box = dev_boxes + cur_box_idx * 5; + int i = 0; + unsigned long long t = 0; + int start = 0; + if (row_start == col_start) { + start = threadIdx.x + 1; + } + for (i = start; i < col_size; i++) { + if (devIoU(cur_box, block_boxes + i * 5) > nms_overlap_thresh) { + t |= 1ULL << i; + } + } + const int col_blocks = THCCeilDiv(n_boxes, threadsPerBlock); + dev_mask[cur_box_idx * col_blocks + col_start] = t; + } +} + +// boxes is a N x 5 tensor +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh) { + using scalar_t = float; + AT_ASSERTM(boxes.type().is_cuda(), "boxes must be a CUDA tensor"); + auto scores = boxes.select(1, 4); + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + auto boxes_sorted = boxes.index_select(0, order_t); + + int boxes_num = boxes.size(0); + + const int col_blocks = THCCeilDiv(boxes_num, threadsPerBlock); + + scalar_t* boxes_dev = boxes_sorted.data(); + + THCState *state = at::globalContext().lazyInitCUDA(); // TODO replace with getTHCState + + unsigned long long* mask_dev = NULL; + //THCudaCheck(THCudaMalloc(state, (void**) &mask_dev, + // boxes_num * col_blocks * sizeof(unsigned long long))); + + mask_dev = (unsigned long long*) THCudaMalloc(state, boxes_num * col_blocks * sizeof(unsigned long long)); + + dim3 blocks(THCCeilDiv(boxes_num, threadsPerBlock), + THCCeilDiv(boxes_num, threadsPerBlock)); + dim3 threads(threadsPerBlock); + nms_kernel<<>>(boxes_num, + nms_overlap_thresh, + boxes_dev, + mask_dev); + + std::vector mask_host(boxes_num * col_blocks); + THCudaCheck(cudaMemcpy(&mask_host[0], + mask_dev, + sizeof(unsigned long long) * boxes_num * col_blocks, + cudaMemcpyDeviceToHost)); + + std::vector remv(col_blocks); + memset(&remv[0], 0, sizeof(unsigned long long) * col_blocks); + + at::Tensor keep = at::empty({boxes_num}, boxes.options().dtype(at::kLong).device(at::kCPU)); + int64_t* keep_out = keep.data(); + + int num_to_keep = 0; + for (int i = 0; i < boxes_num; i++) { + int nblock = i / threadsPerBlock; + int inblock = i % threadsPerBlock; + + if (!(remv[nblock] & (1ULL << inblock))) { + keep_out[num_to_keep++] = i; + unsigned long long *p = &mask_host[0] + i * col_blocks; + for (int j = nblock; j < col_blocks; j++) { + remv[j] |= p[j]; + } + } + } + + THCudaFree(state, mask_dev); + // TODO improve this part + return std::get<0>(order_t.index({ + keep.narrow(/*dim=*/0, /*start=*/0, /*length=*/num_to_keep).to( + order_t.device(), keep.scalar_type()) + }).sort(0, false)); +} diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.h b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.h new file mode 100755 index 0000000000000000000000000000000000000000..373072de3c36bc43adc67539935a9f904eec1b46 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms.h @@ -0,0 +1,28 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include "vision_cpu.h" + +#ifdef WITH_CUDA +#include "vision_cuda.h" +#endif + + +at::Tensor nms(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + + if (dets.type().is_cuda()) { +#ifdef WITH_CUDA + // TODO raise error if not compiled with CUDA + if (dets.numel() == 0) + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + auto b = at::cat({dets, scores.unsqueeze(1)}, 1); + return nms_cuda(b, threshold); +#else + AT_ERROR("Not compiled with GPU support"); +#endif + } + + at::Tensor result = nms_cpu(dets, scores, threshold); + return result; +} diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms_cpu.cpp b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms_cpu.cpp new file mode 100755 index 0000000000000000000000000000000000000000..be73d69d11c63d59ab08dbc832609c3cb76a9aea --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/nms_cpu.cpp @@ -0,0 +1,75 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#include "vision_cpu.h" + + +template +at::Tensor nms_cpu_kernel(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + AT_ASSERTM(!dets.type().is_cuda(), "dets must be a CPU tensor"); + AT_ASSERTM(!scores.type().is_cuda(), "scores must be a CPU tensor"); + AT_ASSERTM(dets.type() == scores.type(), "dets should have the same type as scores"); + + if (dets.numel() == 0) { + return at::empty({0}, dets.options().dtype(at::kLong).device(at::kCPU)); + } + + auto x1_t = dets.select(1, 0).contiguous(); + auto y1_t = dets.select(1, 1).contiguous(); + auto x2_t = dets.select(1, 2).contiguous(); + auto y2_t = dets.select(1, 3).contiguous(); + + at::Tensor areas_t = (x2_t - x1_t + 1) * (y2_t - y1_t + 1); + + auto order_t = std::get<1>(scores.sort(0, /* descending=*/true)); + + auto ndets = dets.size(0); + at::Tensor suppressed_t = at::zeros({ndets}, dets.options().dtype(at::kByte).device(at::kCPU)); + + auto suppressed = suppressed_t.data(); + auto order = order_t.data(); + auto x1 = x1_t.data(); + auto y1 = y1_t.data(); + auto x2 = x2_t.data(); + auto y2 = y2_t.data(); + auto areas = areas_t.data(); + + for (int64_t _i = 0; _i < ndets; _i++) { + auto i = order[_i]; + if (suppressed[i] == 1) + continue; + auto ix1 = x1[i]; + auto iy1 = y1[i]; + auto ix2 = x2[i]; + auto iy2 = y2[i]; + auto iarea = areas[i]; + + for (int64_t _j = _i + 1; _j < ndets; _j++) { + auto j = order[_j]; + if (suppressed[j] == 1) + continue; + auto xx1 = std::max(ix1, x1[j]); + auto yy1 = std::max(iy1, y1[j]); + auto xx2 = std::min(ix2, x2[j]); + auto yy2 = std::min(iy2, y2[j]); + + auto w = std::max(static_cast(0), xx2 - xx1 + 1); + auto h = std::max(static_cast(0), yy2 - yy1 + 1); + auto inter = w * h; + auto ovr = inter / (iarea + areas[j] - inter); + if (ovr >= threshold) + suppressed[j] = 1; + } + } + return at::nonzero(suppressed_t == 0).squeeze(1); +} + +at::Tensor nms_cpu(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold) { + at::Tensor result; + AT_DISPATCH_FLOATING_TYPES(dets.type(), "nms", [&] { + result = nms_cpu_kernel(dets, scores, threshold); + }); + return result; +} diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cpu.h b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cpu.h new file mode 100755 index 0000000000000000000000000000000000000000..92611253616c16efdbed66318da9930b233ae09c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cpu.h @@ -0,0 +1,16 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include + + +at::Tensor ROIAlign_forward_cpu(const at::Tensor& input, + const at::Tensor& rois, + const float spatial_scale, + const int pooled_height, + const int pooled_width, + const int sampling_ratio); + + +at::Tensor nms_cpu(const at::Tensor& dets, + const at::Tensor& scores, + const float threshold); diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cuda.h b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cuda.h new file mode 100755 index 0000000000000000000000000000000000000000..cf194532ca626511768caf941616ca2938ad55e4 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/nms/vision_cuda.h @@ -0,0 +1,10 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +#pragma once +#include + +at::Tensor nms_cuda(const at::Tensor boxes, float nms_overlap_thresh); + + +at::Tensor compute_flow_cuda(const at::Tensor& boxes, + const int height, + const int width); diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/vision.cpp b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/vision.cpp new file mode 100755 index 0000000000000000000000000000000000000000..ac5721b18fc0300ae4edd4c0e21ab3c720a7bec2 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/csrc/vision.cpp @@ -0,0 +1,12 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +#include +#include "nms/nms.h" + +namespace bottom_up_attention { + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("nms", &nms, "non-maximum suppression"); +} + +} // namespace bottom_up_attention diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/nms.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/nms.py new file mode 100755 index 0000000000000000000000000000000000000000..2f9226f2dfaaf3d4e6ae59be3270132b365c2475 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/nms.py @@ -0,0 +1,77 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. +# from ._utils import _C +from detectron2 import _C +# from models.bua import _C + +from apex import amp +import torch + +# Only valid with fp32 inputs - give AMP the hint +nms = amp.float_function(_C.nms) + +# nms.__doc__ = """ +# This function performs Non-maximum suppresion""" + +# NOTE: In order to be consistent with bottom-up-attention, we nms core function from maskrcnn-benchmark + +def batched_nms(boxes, scores, idxs, iou_threshold): + """ + Same as torchvision.ops.boxes.batched_nms, but safer. + """ + assert boxes.shape[-1] == 4 + boxes = boxes.cpu() + scores = scores.cpu() + # TODO may need better strategy. + # Investigate after having a fully-cuda NMS op. + if len(boxes) < 40000: + return box_ops_batched_nms(boxes, scores, idxs, iou_threshold) + + result_mask = scores.new_zeros(scores.size(), dtype=torch.bool) + for id in torch.unique(idxs).cpu().tolist(): + # if id == 0: + # continue + mask = (idxs == id).nonzero().view(-1) + keep = nms(boxes[mask], scores[mask], iou_threshold) + result_mask[mask[keep]] = True + keep = result_mask.nonzero().view(-1) + keep = keep[scores[keep].argsort(descending=True)] + return keep + +def box_ops_batched_nms(boxes, scores, idxs, iou_threshold): + """ + Performs non-maximum suppression in a batched fashion. + + Each index value correspond to a category, and NMS + will not be applied between elements of different categories. + + Parameters + ---------- + boxes : Tensor[N, 4] + boxes where NMS will be performed. They + are expected to be in (x1, y1, x2, y2) format + scores : Tensor[N] + scores for each one of the boxes + idxs : Tensor[N] + indices of the categories for each one of the boxes. + iou_threshold : float + discards all overlapping boxes + with IoU < iou_threshold + + Returns + ------- + keep : Tensor + int64 tensor with the indices of + the elements that have been kept by NMS, sorted + in decreasing order of scores + """ + if boxes.numel() == 0: + return torch.empty((0,), dtype=torch.int64, device=boxes.device) + # strategy: in order to perform NMS independently per class. + # we add an offset to all the boxes. The offset is dependent + # only on the class idx, and is large enough so that boxes + # from different classes do not overlap + max_coordinate = boxes.max() + offsets = idxs.to(boxes) * (max_coordinate + 1) + boxes_for_nms = boxes + offsets[:, None] + keep = nms(boxes_for_nms, scores, iou_threshold) + return keep diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/wrappers.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/wrappers.py new file mode 100755 index 0000000000000000000000000000000000000000..cd0adeef84700257c8f4e039f9b5b3b74ae3de9e --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/layers/wrappers.py @@ -0,0 +1,38 @@ +import math +import torch +from torch.nn.modules.utils import _ntuple + +class Conv2dv2(torch.nn.Conv2d): + """ + A wrapper around :class:`torch.nn.Conv2d` to support more features. + """ + + def __init__(self, *args, **kwargs): + """ + Extra keyword arguments supported in addition to those in `torch.nn.Conv2d`: + + Args: + norm (nn.Module, optional): a normalization layer + activation (callable(Tensor) -> Tensor): a callable activation function + + It assumes that norm layer is used before activation. + """ + norm = kwargs.pop("norm", None) + activation = kwargs.pop("activation", None) + super().__init__(*args, **kwargs) + + self.norm = norm + self.activation = activation + + def forward(self, x): + if x.numel() == 0 and self.training: + # https://github.com/pytorch/pytorch/issues/12013 + assert not isinstance( + self.norm, torch.nn.SyncBatchNorm + ), "SyncBatchNorm does not support empty inputs!" + if self.norm is not None: + x = self.norm(x) + if self.activation is not None: + x = self.activation(x) + x = super().forward(x) + return x \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/postprocessing.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/postprocessing.py new file mode 100755 index 0000000000000000000000000000000000000000..5a51ba4fca65f16819f3445da98684c4931073cf --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/postprocessing.py @@ -0,0 +1,55 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +import numpy as np +import torch + +from detectron2.structures import Instances +from .layers.nms import nms # BC-compat + +def extractor_postprocess(boxes, scores, features_pooled, input_per_image, extractor): + """ + Resize the output instances. + The input images are often resized when entering an object detector. + As a result, we often need the outputs of the detector in a different + resolution from its inputs. + + This function will resize the raw outputs of an R-CNN detector + to produce outputs according to the desired output resolution. + + Args: + results (Instances): the raw outputs from the detector. + `results.image_size` contains the input image resolution the detector sees. + This object might be modified in-place. + output_height, output_width: the desired output resolution. + + Returns: + Instances: the resized output from the model, based on the output resolution + """ + MIN_BOXES = extractor.MIN_BOXES + MAX_BOXES = extractor.MAX_BOXES + CONF_THRESH = extractor.CONF_THRESH + + cur_device = scores.device + + dets = boxes / input_per_image["im_scale"] + + max_conf = torch.zeros((scores.shape[0])).to(cur_device) + + for cls_ind in range(1, scores.shape[1]): + cls_scores = scores[:, cls_ind] + keep = nms(dets, cls_scores, 0.3) + max_conf[keep] = torch.where(cls_scores[keep] > max_conf[keep], + cls_scores[keep], + max_conf[keep]) + + keep_boxes = torch.nonzero(max_conf >= CONF_THRESH).flatten() + if len(keep_boxes) < MIN_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MIN_BOXES] + elif len(keep_boxes) > MAX_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MAX_BOXES] + # keep_boxes = torch.argsort(max_conf, descending=True)[:100] + # feat_list.append(feats[i][keep_boxes]) + image_feat = features_pooled[keep_boxes] + image_bboxes = dets[keep_boxes] + + return image_feat, image_bboxes \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rcnn.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rcnn.py new file mode 100755 index 0000000000000000000000000000000000000000..167a9f2e18e888ee4aa29ec20d02e57911c848fc --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rcnn.py @@ -0,0 +1,172 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import logging, os +import torch +from torch import nn +import torch.nn.functional as F + +from detectron2.structures import ImageList +from detectron2.utils.logger import log_first_n + +from detectron2.modeling.backbone import build_backbone +from detectron2.modeling.postprocessing import detector_postprocess +from detectron2.modeling.proposal_generator import build_proposal_generator +from detectron2.modeling.roi_heads import build_roi_heads +from detectron2.modeling.meta_arch import META_ARCH_REGISTRY +import time +# from models.bua_caffe.postprocessing import extractor_postprocess +#from utils import save_features + +__all__ = ["GeneralizedBUARCNN"] + + +@META_ARCH_REGISTRY.register() +class GeneralizedBUARCNN(nn.Module): + """ + Generalized R-CNN. Any models that contains the following three components: + 1. Per-image feature extraction (aka backbone) + 2. Region proposal generation + 3. Per-region feature extraction and prediction + """ + + def __init__(self, cfg): + super().__init__() + + self.device = torch.device(cfg.MODEL.DEVICE) + self.bua_caffe = cfg.MODEL.BUA.CAFFE + self.resnet_version = cfg.MODEL.BUA.RESNET_VERSION + self.backbone = build_backbone(cfg) + self.in_features = cfg.MODEL.RPN.IN_FEATURES + self.proposal_generator = build_proposal_generator(cfg, self.backbone.output_shape()) + self.roi_heads = build_roi_heads(cfg, self.backbone.output_shape()) + + assert len(cfg.MODEL.PIXEL_MEAN) == len(cfg.MODEL.PIXEL_STD) + self.extract_on = cfg.MODEL.BUA.EXTRACT_FEATS + self.extractor = cfg.MODEL.BUA.EXTRACTOR + self.to(self.device) + + def forward(self, batched_inputs): + """ + Args: + batched_inputs: a list, batched outputs of :class:`DatasetMapper` . + Each item in the list contains the inputs for one image. + For now, each item in the list is a dict that contains: + + * image: Tensor, image in (C, H, W) format. + * instances (optional): groundtruth :class:`Instances` + * proposals (optional): :class:`Instances`, precomputed proposals. + + Other information that's included in the original dicts, such as: + + * "height", "width" (int): the output resolution of the model, used in inference. + See :meth:`postprocess` for details. + + Returns: + list[dict]: + Each dict is the output for one input image. + The dict contains one key "instances" whose value is a :class:`Instances`. + The :class:`Instances` object has the following keys: + "pred_boxes", "pred_classes", "scores", "pred_masks", "pred_keypoints" + """ + if not self.training: + return self.inference(batched_inputs) + + images = self.preprocess_image(batched_inputs) + if "instances" in batched_inputs[0]: + gt_instances = [x["instances"].to(self.device) for x in batched_inputs] + elif "targets" in batched_inputs[0]: + log_first_n( + logging.WARN, "'targets' in the model inputs is now renamed to 'instances'!", n=10 + ) + gt_instances = [x["targets"].to(self.device) for x in batched_inputs] + else: + gt_instances = None + + features = self.backbone(images.tensor) + + if self.resnet_version == 2: + for f in features: + out = self.roi_heads.res5[0].norm(features[f]) + features[f] = F.relu_(out) + + if self.proposal_generator: + proposals, proposal_losses = self.proposal_generator(images, features, gt_instances) + else: + assert "proposals" in batched_inputs[0] + proposals = [x["proposals"].to(self.device) for x in batched_inputs] + proposal_losses = {} + + _, detector_losses = self.roi_heads(images, features, proposals, gt_instances) + + losses = {} + losses.update(detector_losses) + losses.update(proposal_losses) + return losses + + def inference(self, batched_inputs, detected_instances=None, do_postprocess=True): + """ + Run inference on the given inputs. + + Args: + batched_inputs (list[dict]): same as in :meth:`forward` + detected_instances (None or list[Instances]): if not None, it + contains an `Instances` object per image. The `Instances` + object contains "pred_boxes" and "pred_classes" which are + known boxes in the image. + The inference will then skip the detection of bounding boxes, + and only predict other per-ROI outputs. + do_postprocess (bool): whether to apply post-processing on the outputs. + + Returns: + same as in :meth:`forward`. + """ + assert not self.training + + images = self.preprocess_image(batched_inputs) +# time_a = time.time() + features = self.backbone(images.tensor) +# time_b = time.time() +# print("time cost:{}".format(time_b - time_a)) +# print("features shape:", features["res4"].shape) + if self.resnet_version == 2: + for f in features: + out = self.roi_heads.res5[0].norm(features[f]) + features[f] = F.relu_(out) + + if detected_instances is None: + if self.proposal_generator: + proposals, _ = self.proposal_generator(images, features, None) + else: + assert "proposals" in batched_inputs[0] + proposals = [x["proposals"].to(self.device) for x in batched_inputs] + + if self.extract_on: + return self.roi_heads(images, features, proposals, None) + else: + results, _ = self.roi_heads(images, features, proposals, None) + else: + detected_instances = [x.to(self.device) for x in detected_instances] + results = self.roi_heads.forward_with_given_boxes(features, detected_instances) + + if do_postprocess: + processed_results = [] + for results_per_image, input_per_image, image_size in zip( + results, batched_inputs, images.image_sizes + ): + height = input_per_image.get("height", image_size[0]) + width = input_per_image.get("width", image_size[1]) + if not self.bua_caffe: + results_per_image = detector_postprocess(results_per_image, height, width) + processed_results.append({"instances": results_per_image}) + return processed_results + else: + return results + + def preprocess_image(self, batched_inputs): + """ + Normalize, pad and batch the input images. + """ + images = [x["image"].to(self.device) for x in batched_inputs] + image_scales = [x["im_scale"] for x in batched_inputs] + images = ImageList.from_tensors(images, self.backbone.size_divisibility) + images.image_scales = image_scales + return images diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/roi_heads.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/roi_heads.py new file mode 100755 index 0000000000000000000000000000000000000000..43222605305460155847dfe90ea325b70f2713e1 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/roi_heads.py @@ -0,0 +1,460 @@ +# -*- coding: utf-8 -*- +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import numpy as np +import torch +import torch.nn as nn +from torch.nn import functional as F + +from detectron2.utils.events import get_event_storage +from detectron2.modeling import ROI_HEADS_REGISTRY, ROIHeads +from detectron2.structures import Boxes, Instances, pairwise_iou +from detectron2.modeling.sampling import subsample_labels +from detectron2.modeling.poolers import ROIPooler +from detectron2.modeling.backbone.resnet import BottleneckBlock +from detectron2.modeling.proposal_generator.proposal_utils import add_ground_truth_to_proposals +from detectron2.layers import get_norm, BatchNorm2d + +from .fast_rcnn import BUACaffeFastRCNNOutputs, BUACaffeFastRCNNOutputLayers, BUADetection2FastRCNNOutputs, BUADetectron2FastRCNNOutputLayers +from .box_regression import BUABox2BoxTransform +from .backbone import BottleneckBlockv2 + +def make_stage(block_class, num_blocks, first_stride, **kwargs): + """ + Create a resnet stage by creating many blocks. + Args: + block_class (class): a subclass of ResNetBlockBase + num_blocks (int): + first_stride (int): the stride of the first block. The other blocks will have stride=1. + A `stride` argument will be passed to the block constructor. + kwargs: other arguments passed to the block constructor. + + Returns: + list[nn.Module]: a list of block module. + """ + blocks = [] + for i in range(num_blocks): + if kwargs["dilation"] > 1: + first_stride = 1 + blocks.append(block_class(stride=first_stride if i == 0 else 1, **kwargs)) + kwargs["in_channels"] = kwargs["out_channels"] + return blocks + +@ROI_HEADS_REGISTRY.register() +class BUACaffeRes5ROIHeads(ROIHeads): + """ + The ROIHeads in a typical "C4" R-CNN model, where + the box and mask head share the cropping and + the per-region feature computation by a Res5 block. + """ + + def __init__(self, cfg, input_shape): + # super().__init__(cfg, input_shape) + super().__init__(cfg) + + self.in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES + self.feature_strides = {k: v.stride for k, v in input_shape.items()} + self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG + self.smooth_l1_beta = cfg.MODEL.ROI_BOX_HEAD.SMOOTH_L1_BETA + assert len(self.in_features) == 1 + + # fmt: off + pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION + pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE + pooler_scales = (1.0 / self.feature_strides[self.in_features[0]], ) + sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO + self.resnet_version = cfg.MODEL.BUA.RESNET_VERSION + self.attr_on = cfg.MODEL.BUA.ATTRIBUTE_ON + self.extract_on = cfg.MODEL.BUA.EXTRACT_FEATS + self.num_attr_classes = cfg.MODEL.BUA.ATTRIBUTE.NUM_CLASSES + self.extractor_mode = cfg.MODEL.BUA.EXTRACTOR.MODE + + self.pooler = ROIPooler( + output_size=pooler_resolution, + scales=pooler_scales, + sampling_ratio=sampling_ratio, + pooler_type=pooler_type, + ) + + self.box2box_transform = BUABox2BoxTransform(weights=cfg.MODEL.ROI_BOX_HEAD.BBOX_REG_WEIGHTS) + + self.res5, out_channels = self._build_res5_block(cfg) + if self.resnet_version == 2: + self.res5_bn = BatchNorm2d(out_channels, eps=2e-5) + self.box_predictor = BUACaffeFastRCNNOutputLayers( + out_channels, self.num_classes, self.cls_agnostic_bbox_reg, attr_on=self.attr_on, num_attr_classes=self.num_attr_classes + ) + + def _build_res5_block(self, cfg): + # fmt: off + stage_channel_factor = 2 ** 3 # res5 is 8x res2 + num_groups = cfg.MODEL.RESNETS.NUM_GROUPS + width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP + bottleneck_channels = num_groups * width_per_group * stage_channel_factor + out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS * stage_channel_factor + stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1 + norm = cfg.MODEL.RESNETS.NORM + dilation = cfg.MODEL.RESNETS.RES5_DILATION + assert not cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE[-1], \ + "Deformable conv is not yet supported in res5 head." + # fmt: on + blocks = make_stage( + BottleneckBlock if self.resnet_version == 1 else BottleneckBlockv2, + 3, + first_stride=2, + in_channels=out_channels // 2, + bottleneck_channels=bottleneck_channels, + out_channels=out_channels, + num_groups=num_groups, + norm=norm, + stride_in_1x1=stride_in_1x1, + dilation=dilation, + ) + return nn.Sequential(*blocks), out_channels + + def _shared_roi_transform(self, features, boxes): + x = self.pooler(features, boxes) + if self.resnet_version == 2: + out = self.res5[0].conv1(x) + out = self.res5[0].conv2(out) + out = self.res5[0].conv3(out) + if self.res5[0].shortcut is not None: + shortcut = self.res5[0].shortcut(x) + else: + shortcut = x + out += shortcut + out = self.res5[1:](out) + return F.relu_(self.res5_bn(out)) + return self.res5(x) + + def forward(self, images, features, proposals, targets=None): + """ + See :class:`ROIHeads.forward`. + """ + image_scales = images.image_scales + del images + + if self.training: + proposals = self.label_and_sample_proposals(proposals, targets) + del targets + + proposal_boxes = [x.proposal_boxes for x in proposals] + box_features = self._shared_roi_transform( + [features[f] for f in self.in_features], proposal_boxes + ) + feature_pooled = box_features.mean(dim=[2, 3]) # pooled to 1x1 + if self.attr_on: + pred_class_logits, pred_proposal_deltas, attr_scores = self.box_predictor(feature_pooled, proposals) + else: + pred_class_logits, pred_proposal_deltas = self.box_predictor(feature_pooled, proposals) + if not self.extract_on: + del feature_pooled + + outputs = BUACaffeFastRCNNOutputs( + self.box2box_transform, + pred_class_logits, + pred_proposal_deltas, + proposals, + self.smooth_l1_beta, + image_scales + ) + + if self.training: + del features + losses = outputs.losses() + return [], losses + else: + if self.extract_on: + num_preds_per_image = [len(p) for p in proposals] + if self.extractor_mode == 1 or self.extractor_mode == 3: + if self.attr_on: + return proposal_boxes, outputs.predict_probs(), feature_pooled.split(num_preds_per_image, dim=0), attr_scores.split(num_preds_per_image, dim=0) + else: + return proposal_boxes, outputs.predict_probs(), feature_pooled.split(num_preds_per_image, dim=0) + elif self.extractor_mode == 2: + return outputs.predict_boxes(), outputs.predict_probs() + else: + raise ValueError('BUA.EXTRATOR.MODE ERROR') + pred_instances, _ = outputs.inference( + self.test_score_thresh, self.test_nms_thresh, self.test_detections_per_img + ) + return pred_instances, {} + +@ROI_HEADS_REGISTRY.register() +class BUADetectron2Res5ROIHeads(ROIHeads): + """ + The ROIHeads in a typical "C4" R-CNN model, where + the box and mask head share the cropping and + the per-region feature computation by a Res5 block. + """ + + def __init__(self, cfg, input_shape): + # super().__init__(cfg, input_shape) + super().__init__(cfg) + + self.in_features = cfg.MODEL.ROI_HEADS.IN_FEATURES + self.feature_strides = {k: v.stride for k, v in input_shape.items()} + self.cls_agnostic_bbox_reg = cfg.MODEL.ROI_BOX_HEAD.CLS_AGNOSTIC_BBOX_REG + self.smooth_l1_beta = cfg.MODEL.ROI_BOX_HEAD.SMOOTH_L1_BETA + assert len(self.in_features) == 1 + + # fmt: off + pooler_resolution = cfg.MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION + pooler_type = cfg.MODEL.ROI_BOX_HEAD.POOLER_TYPE + pooler_scales = (1.0 / self.feature_strides[self.in_features[0]], ) + sampling_ratio = cfg.MODEL.ROI_BOX_HEAD.POOLER_SAMPLING_RATIO + self.resnet_version = cfg.MODEL.BUA.RESNET_VERSION + self.attr_on = cfg.MODEL.BUA.ATTRIBUTE_ON + self.extract_on = cfg.MODEL.BUA.EXTRACT_FEATS + self.num_attr_classes = cfg.MODEL.BUA.ATTRIBUTE.NUM_CLASSES + self.extractor_mode = cfg.MODEL.BUA.EXTRACTOR.MODE + + self.pooler = ROIPooler( + output_size=pooler_resolution, + scales=pooler_scales, + sampling_ratio=sampling_ratio, + pooler_type=pooler_type, + ) + + # self.box2box_transform = BUABox2BoxTransform(weights=cfg.MODEL.ROI_BOX_HEAD.BBOX_REG_WEIGHTS) + + self.res5, out_channels = self._build_res5_block(cfg) + if self.resnet_version == 2: + self.res5_bn = BatchNorm2d(out_channels, eps=2e-5) + self.box_predictor = BUADetectron2FastRCNNOutputLayers( + out_channels, self.num_classes, self.cls_agnostic_bbox_reg, \ + attr_on=self.attr_on, num_attr_classes=self.num_attr_classes + ) + + def _sample_proposals(self, matched_idxs, matched_labels, gt_classes, gt_attributes): + """ + Based on the matching between N proposals and M groundtruth, + sample the proposals and set their classification labels. + + Args: + matched_idxs (Tensor): a vector of length N, each is the best-matched + gt index in [0, M) for each proposal. + matched_labels (Tensor): a vector of length N, the matcher's label + (one of cfg.MODEL.ROI_HEADS.IOU_LABELS) for each proposal. + gt_classes (Tensor): a vector of length M. + + Returns: + Tensor: a vector of indices of sampled proposals. Each is in [0, N). + Tensor: a vector of the same length, the classification label for + each sampled proposal. Each sample is labeled as either a category in + [0, num_classes) or the background (num_classes). + """ + has_gt = gt_classes.numel() > 0 + # Get the corresponding GT for each proposal + if has_gt: + gt_classes = gt_classes[matched_idxs] + gt_attributes = gt_attributes[matched_idxs, :] + # Label unmatched proposals (0 label from matcher) as background (label=num_classes) + gt_classes[matched_labels == 0] = self.num_classes + # Label ignore proposals (-1 label) + gt_classes[matched_labels == -1] = -1 + else: + gt_classes = torch.zeros_like(matched_idxs) + self.num_classes + gt_clagt_attributes = -torch.ones((len(matched_idxs),16), dtype=torch.int64).cuda() + + sampled_fg_idxs, sampled_bg_idxs = subsample_labels( + gt_classes, self.batch_size_per_image, self.positive_sample_fraction, self.num_classes + ) + + sampled_idxs = torch.cat([sampled_fg_idxs, sampled_bg_idxs], dim=0) + return sampled_idxs, gt_classes[sampled_idxs], gt_attributes[sampled_idxs] + + def _build_res5_block(self, cfg): + # fmt: off + stage_channel_factor = 2 ** 3 # res5 is 8x res2 + num_groups = cfg.MODEL.RESNETS.NUM_GROUPS + width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP + bottleneck_channels = num_groups * width_per_group * stage_channel_factor + out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS * stage_channel_factor + stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1 + norm = cfg.MODEL.RESNETS.NORM + dilation = cfg.MODEL.RESNETS.RES5_DILATION + assert not cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE[-1], \ + "Deformable conv is not yet supported in res5 head." + # fmt: on + + blocks = make_stage( + BottleneckBlock if self.resnet_version == 1 else BottleneckBlockv2, + 3, + first_stride=2, + in_channels=out_channels // 2, + bottleneck_channels=bottleneck_channels, + out_channels=out_channels, + num_groups=num_groups, + norm=norm, + stride_in_1x1=stride_in_1x1, + dilation=dilation, + ) + return nn.Sequential(*blocks), out_channels + + def _shared_roi_transform(self, features, boxes): + x = self.pooler(features, boxes) + if self.resnet_version == 2: + out = self.res5[0].conv1(x) + out = self.res5[0].conv2(out) + out = self.res5[0].conv3(out) + if self.res5[0].shortcut is not None: + shortcut = self.res5[0].shortcut(x) + else: + shortcut = x + out += shortcut + out = self.res5[1:](out) + return F.relu_(self.res5_bn(out)) + return self.res5(x) + + @torch.no_grad() + def label_and_sample_proposals(self, proposals, targets): + """ + Prepare some proposals to be used to train the ROI heads. + It performs box matching between `proposals` and `targets`, and assigns + training labels to the proposals. + It returns ``self.batch_size_per_image`` random samples from proposals and groundtruth + boxes, with a fraction of positives that is no larger than + ``self.positive_sample_fraction``. + + Args: + See :meth:`ROIHeads.forward` + + Returns: + list[Instances]: + length `N` list of `Instances`s containing the proposals + sampled for training. Each `Instances` has the following fields: + + - proposal_boxes: the proposal boxes + - gt_boxes: the ground-truth box that the proposal is assigned to + (this is only meaningful if the proposal has a label > 0; if label = 0 + then the ground-truth box is random) + + Other fields such as "gt_classes", "gt_masks", that's included in `targets`. + """ + gt_boxes = [x.gt_boxes for x in targets] + # Augment proposals with ground-truth boxes. + # In the case of learned proposals (e.g., RPN), when training starts + # the proposals will be low quality due to random initialization. + # It's possible that none of these initial + # proposals have high enough overlap with the gt objects to be used + # as positive examples for the second stage components (box head, + # cls head, mask head). Adding the gt boxes to the set of proposals + # ensures that the second stage components will have some positive + # examples from the start of training. For RPN, this augmentation improves + # convergence and empirically improves box AP on COCO by about 0.5 + # points (under one tested configuration). + if self.proposal_append_gt: + proposals = add_ground_truth_to_proposals(gt_boxes, proposals) + + proposals_with_gt = [] + + num_fg_samples = [] + num_bg_samples = [] + for proposals_per_image, targets_per_image in zip(proposals, targets): + has_gt = len(targets_per_image) > 0 + match_quality_matrix = pairwise_iou( + targets_per_image.gt_boxes, proposals_per_image.proposal_boxes + ) + matched_idxs, matched_labels = self.proposal_matcher(match_quality_matrix) + sampled_idxs, gt_classes, gt_attributes = self._sample_proposals( + matched_idxs, matched_labels, targets_per_image.gt_classes, targets_per_image.gt_attributes + ) + + # Set target attributes of the sampled proposals: + proposals_per_image = proposals_per_image[sampled_idxs] + proposals_per_image.gt_classes = gt_classes + proposals_per_image.gt_attributes = gt_attributes + + # We index all the attributes of targets that start with "gt_" + # and have not been added to proposals yet (="gt_classes"). + if has_gt: + sampled_targets = matched_idxs[sampled_idxs] + # NOTE: here the indexing waste some compute, because heads + # like masks, keypoints, etc, will filter the proposals again, + # (by foreground/background, or number of keypoints in the image, etc) + # so we essentially index the data twice. + for (trg_name, trg_value) in targets_per_image.get_fields().items(): + if trg_name.startswith("gt_") and not proposals_per_image.has(trg_name): + proposals_per_image.set(trg_name, trg_value[sampled_targets]) + else: + gt_boxes = Boxes( + targets_per_image.gt_boxes.tensor.new_zeros((len(sampled_idxs), 4)) + ) + proposals_per_image.gt_boxes = gt_boxes + + num_bg_samples.append((gt_classes == self.num_classes).sum().item()) + num_fg_samples.append(gt_classes.numel() - num_bg_samples[-1]) + proposals_with_gt.append(proposals_per_image) + + # Log the number of fg/bg samples that are selected for training ROI heads + storage = get_event_storage() + storage.put_scalar("roi_head/num_fg_samples", np.mean(num_fg_samples)) + storage.put_scalar("roi_head/num_bg_samples", np.mean(num_bg_samples)) + + return proposals_with_gt + + def forward(self, images, features, proposals, targets=None): + """ + See :class:`ROIHeads.forward`. + """ + image_scales = images.image_scales + del images + + if self.training: + proposals = self.label_and_sample_proposals(proposals, targets) + del targets + + proposal_boxes = [x.proposal_boxes for x in proposals] + box_features = self._shared_roi_transform( + [features[f] for f in self.in_features], proposal_boxes + ) + feature_pooled = box_features.mean(dim=[2, 3]) # pooled to 1x1 + if self.attr_on: + pred_class_logits, pred_proposal_deltas, pred_attribute_logits, gt_attributes = self.box_predictor(feature_pooled, proposals) + else: + pred_class_logits, pred_proposal_deltas = self.box_predictor(feature_pooled, proposals) + if not self.extract_on: + del feature_pooled + + if self.attr_on: + outputs = BUADetection2FastRCNNOutputs( + self.box2box_transform, + pred_class_logits, + pred_proposal_deltas, + proposals, + self.smooth_l1_beta, + self.attr_on, + pred_attribute_logits=pred_attribute_logits, + num_attr_classes=self.num_attr_classes, + gt_attributes=gt_attributes, + ) + else: + outputs = BUADetection2FastRCNNOutputs( + self.box2box_transform, + pred_class_logits, + pred_proposal_deltas, + proposals, + self.smooth_l1_beta, + self.attr_on, + ) + + if self.training: + del features + losses = outputs.losses() + return [], losses + else: + if self.extract_on: + num_preds_per_image = [len(p) for p in proposals] + if self.extractor_mode == 1 or self.extractor_mode == 3: + if self.attr_on: + return proposal_boxes, outputs.predict_probs(), feature_pooled.split(num_preds_per_image, dim=0), F.softmax(pred_attribute_logits, dim=-1).split(num_preds_per_image, dim=0) + else: + return proposal_boxes, outputs.predict_probs(), feature_pooled.split(num_preds_per_image, dim=0) + elif self.extractor_mode == 2: + return outputs.predict_boxes(), outputs.predict_probs() + else: + raise ValueError('BUA.EXTRATOR.MODE ERROR') + pred_instances, _ = outputs.inference( + self.test_score_thresh, self.test_nms_thresh, self.test_detections_per_img + ) + return pred_instances, {} diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn.py new file mode 100755 index 0000000000000000000000000000000000000000..8336c1021bff07f11e5bb98eda6af1e3053565c1 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn.py @@ -0,0 +1,176 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +from typing import Dict, List + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from detectron2.modeling import RPN_HEAD_REGISTRY +from detectron2.layers import ShapeSpec + +from detectron2.modeling.proposal_generator import build_rpn_head +from detectron2.modeling.proposal_generator.build import PROPOSAL_GENERATOR_REGISTRY +from detectron2.modeling.anchor_generator import build_anchor_generator +from .box_regression import BUABox2BoxTransform +from detectron2.modeling.matcher import Matcher +from .rpn_outputs import BUARPNOutputs, find_top_bua_rpn_proposals + +@RPN_HEAD_REGISTRY.register() +class StandardBUARPNHead(nn.Module): + """ + RPN classification and regression heads. Uses a 3x3 conv to produce a shared + hidden state from which one 1x1 conv predicts objectness logits for each anchor + and a second 1x1 conv predicts bounding-box deltas specifying how to deform + each anchor into an object proposal. + """ + + def __init__(self, cfg, input_shape: List[ShapeSpec]): + super().__init__() + + # Standard RPN is shared across levels: + out_channels = cfg.MODEL.BUA.RPN.CONV_OUT_CHANNELS + + in_channels = [s.channels for s in input_shape] + assert len(set(in_channels)) == 1, "Each level must have the same channel!" + in_channels = in_channels[0] + + # RPNHead should take the same input as anchor generator + # NOTE: it assumes that creating an anchor generator does not have unwanted side effect. + anchor_generator = build_anchor_generator(cfg, input_shape) + num_cell_anchors = anchor_generator.num_cell_anchors + box_dim = anchor_generator.box_dim + assert ( + len(set(num_cell_anchors)) == 1 + ), "Each level must have the same number of cell anchors" + num_cell_anchors = num_cell_anchors[0] + + # 3x3 conv for the hidden representation + self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1) + # 1x1 conv for predicting objectness logits + self.objectness_logits = nn.Conv2d(out_channels, num_cell_anchors * 2, kernel_size=1, stride=1) + # 1x1 conv for predicting box2box transform deltas + self.anchor_deltas = nn.Conv2d( + out_channels, num_cell_anchors * box_dim, kernel_size=1, stride=1 + ) + + for l in [self.conv, self.objectness_logits, self.anchor_deltas]: + nn.init.normal_(l.weight, std=0.01) + nn.init.constant_(l.bias, 0) + + def forward(self, features): + """ + Args: + features (list[Tensor]): list of feature maps + """ + pred_objectness_logits = [] + pred_anchor_deltas = [] + for x in features: + t = F.relu(self.conv(x)) + pred_objectness_logits.append(self.objectness_logits(t)) + pred_anchor_deltas.append(self.anchor_deltas(t)) + return pred_objectness_logits, pred_anchor_deltas + +@PROPOSAL_GENERATOR_REGISTRY.register() +class BUARPN(nn.Module): + """ + Region Proposal Network, introduced by the Faster R-CNN paper. + """ + + def __init__(self, cfg, input_shape: Dict[str, ShapeSpec]): + super().__init__() + + # fmt: off + self.min_box_side_len = cfg.MODEL.PROPOSAL_GENERATOR.MIN_SIZE + self.in_features = cfg.MODEL.RPN.IN_FEATURES + self.nms_thresh = cfg.MODEL.RPN.NMS_THRESH + self.batch_size_per_image = cfg.MODEL.RPN.BATCH_SIZE_PER_IMAGE + self.positive_fraction = cfg.MODEL.RPN.POSITIVE_FRACTION + self.smooth_l1_beta = cfg.MODEL.RPN.SMOOTH_L1_BETA + self.loss_weight = cfg.MODEL.RPN.LOSS_WEIGHT + # fmt: on + + # Map from self.training state to train/test settings + self.pre_nms_topk = { + True: cfg.MODEL.RPN.PRE_NMS_TOPK_TRAIN, + False: cfg.MODEL.RPN.PRE_NMS_TOPK_TEST, + } + self.post_nms_topk = { + True: cfg.MODEL.RPN.POST_NMS_TOPK_TRAIN, + False: cfg.MODEL.RPN.POST_NMS_TOPK_TEST, + } + self.boundary_threshold = cfg.MODEL.RPN.BOUNDARY_THRESH + + self.anchor_generator = build_anchor_generator( + cfg, [input_shape[f] for f in self.in_features] + ) + self.box2box_transform = BUABox2BoxTransform(weights=cfg.MODEL.RPN.BBOX_REG_WEIGHTS) + self.anchor_matcher = Matcher( + cfg.MODEL.RPN.IOU_THRESHOLDS, cfg.MODEL.RPN.IOU_LABELS, allow_low_quality_matches=True + ) + self.rpn_head = build_rpn_head(cfg, [input_shape[f] for f in self.in_features]) + + def forward(self, images, features, gt_instances=None): + """ + Args: + images (ImageList): input images of length `N` + features (dict[str: Tensor]): input data as a mapping from feature + map name to tensor. Axis 0 represents the number of images `N` in + the input data; axes 1-3 are channels, height, and width, which may + vary between feature maps (e.g., if a feature pyramid is used). + gt_instances (list[Instances], optional): a length `N` list of `Instances`s. + Each `Instances` stores ground-truth instances for the corresponding image. + + Returns: + proposals: list[Instances] or None + loss: dict[Tensor] + """ + gt_boxes = [x.gt_boxes for x in gt_instances] if gt_instances is not None else None + del gt_instances + features = [features[f] for f in self.in_features] + pred_objectness_logits, pred_anchor_deltas = self.rpn_head(features) + anchors = self.anchor_generator(features) + # TODO: The anchors only depend on the feature map shape; there's probably + # an opportunity for some optimizations (e.g., caching anchors). + outputs = BUARPNOutputs( + self.box2box_transform, + self.anchor_matcher, + self.batch_size_per_image, + self.positive_fraction, + images, + pred_objectness_logits, + pred_anchor_deltas, + anchors, + self.boundary_threshold, + gt_boxes, + self.smooth_l1_beta, + ) + + if self.training: + losses = {k: v * self.loss_weight for k, v in outputs.losses().items()} + else: + losses = {} + + with torch.no_grad(): + # Find the top proposals by applying NMS and removing boxes that + # are too small. The proposals are treated as fixed for approximate + # joint training with roi heads. This approach ignores the derivative + # w.r.t. the proposal boxes’ coordinates that are also network + # responses, so is approximate. + proposals = find_top_bua_rpn_proposals( + outputs.predict_proposals(), + outputs.predict_objectness_logits(), + images, + self.nms_thresh, + self.pre_nms_topk[self.training], + self.post_nms_topk[self.training], + self.min_box_side_len, + self.training, + ) + # For RPN-only models, the proposals are the final output and we return them in + # high-to-low confidence order. + # For end-to-end models, the RPN proposals are an intermediate state + # and this sorting is actually not needed. But the cost is negligible. + # inds = [p.objectness_logits.sort(descending=True)[1] for p in proposals] + # proposals = [p[ind] for p, ind in zip(proposals, inds)] + + return proposals, losses \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn_outputs.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn_outputs.py new file mode 100755 index 0000000000000000000000000000000000000000..8b779a854b7dce6ad6f27f7b70b78ab86fd152b6 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_models/bua/rpn_outputs.py @@ -0,0 +1,404 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved +import itertools +import logging +import numpy as np +import torch +import torch.nn.functional as F +from fvcore.nn import smooth_l1_loss + +from detectron2.layers import cat +from detectron2.structures import Instances, pairwise_iou +from detectron2.utils.events import get_event_storage + +from detectron2.modeling.sampling import subsample_labels + +from .box_regression import BUABoxes +from detectron2.layers.nms import batched_nms + +def find_top_bua_rpn_proposals( + proposals, + pred_objectness_logits, + images, + nms_thresh, + pre_nms_topk, + post_nms_topk, + min_box_side_len, + training, +): + """ + For each feature map, select the `pre_nms_topk` highest scoring proposals, + apply NMS, clip proposals, and remove small boxes. Return the `post_nms_topk` + highest scoring proposals among all the feature maps if `training` is True, + otherwise, returns the highest `post_nms_topk` scoring proposals for each + feature map. + + Args: + proposals (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A, 4). + All proposal predictions on the feature maps. + pred_objectness_logits (list[Tensor]): A list of L tensors. Tensor i has shape (N, Hi*Wi*A). + images (ImageList): Input images as an :class:`ImageList`. + nms_thresh (float): IoU threshold to use for NMS + pre_nms_topk (int): number of top k scoring proposals to keep before applying NMS. + When RPN is run on multiple feature maps (as in FPN) this number is per + feature map. + post_nms_topk (int): number of top k scoring proposals to keep after applying NMS. + When RPN is run on multiple feature maps (as in FPN) this number is total, + over all feature maps. + min_box_side_len (float): minimum proposal box side length in pixels (absolute units + wrt input images). + training (bool): True if proposals are to be used in training, otherwise False. + This arg exists only to support a legacy bug; look for the "NB: Legacy bug ..." + comment. + + Returns: + proposals (list[Instances]): list of N Instances. The i-th Instances + stores post_nms_topk object proposals for image i. + """ + image_sizes = images.image_sizes # in (h, w) order + image_scales = images.image_scales + device = proposals[0].device + + # 1. Concat all levels together + all_scores = [] + all_proposals = [] + level_ids = [] + for level_id, proposals_i, logits_i in zip( + itertools.count(), proposals, pred_objectness_logits + ): + Hi_Wi_A = logits_i.shape[1] + all_proposals.append(proposals_i) + all_scores.append(logits_i) + level_ids.append(torch.full((Hi_Wi_A,), level_id, dtype=torch.int64, device=device)) + + all_scores = cat(all_scores, dim=1) + all_proposals = cat(all_proposals, dim=1) + level_ids = cat(level_ids, dim=0) + + # 2. For each image, run a choose pre_nms_topk proposal ,per-level NMS, and choose post_nms_topk results. + results = [] + for n, image_size in enumerate(image_sizes): + boxes = BUABoxes(all_proposals[n]) + scores_per_img = all_scores[n] + boxes.clip(image_size) + keep = boxes.filter_boxes() + boxes = boxes[keep] + scores_per_img = scores_per_img[keep] + lvl = level_ids[keep] + + # filter empty boxes + keep = boxes.nonempty(threshold=min_box_side_len*image_scales[n]) + if keep.sum().item() != len(boxes): + boxes, scores_per_img, lvl = boxes[keep], scores_per_img[keep], lvl[keep] + + # choose pre_nms_topk proposal + Hi_Wi_A = scores_per_img.shape[0] + num_proposals_i = min(pre_nms_topk, Hi_Wi_A) + + scores_per_img, idx = scores_per_img.sort(descending=True, dim=0) + topk_scores_i = scores_per_img[:num_proposals_i] + topk_idx = idx[:num_proposals_i] + topk_boxes_i = boxes[topk_idx, :] + lvl_i = lvl[topk_idx] + + keep = batched_nms(topk_boxes_i.tensor, topk_scores_i, lvl_i, nms_thresh) + # In Detectron1, there was different behavior during training vs. testing. + # (https://github.com/facebookresearch/Detectron/issues/459) + # During training, topk is over the proposals from *all* images in the training batch. + # During testing, it is over the proposals for each image separately. + # As a result, the training behavior becomes batch-dependent, + # and the configuration "POST_NMS_TOPK_TRAIN" end up relying on the batch size. + # This bug is addressed in Detectron2 to make the behavior independent of batch size. + keep = keep[:post_nms_topk] + + res = Instances(image_size) + res.proposal_boxes = topk_boxes_i[keep] + res.objectness_logits = topk_scores_i[keep] + results.append(res) + return results + +class BUARPNOutputs(object): + def __init__( + self, + box2box_transform, + anchor_matcher, + batch_size_per_image, + positive_fraction, + images, + pred_objectness_logits, + pred_anchor_deltas, + anchors, + boundary_threshold=0, + gt_boxes=None, + smooth_l1_beta=0.0, + ): + """ + Args: + box2box_transform (Box2BoxTransform): :class:`Box2BoxTransform` instance for + anchor-proposal transformations. + anchor_matcher (Matcher): :class:`Matcher` instance for matching anchors to + ground-truth boxes; used to determine training labels. + batch_size_per_image (int): number of proposals to sample when training + positive_fraction (float): target fraction of sampled proposals that should be positive + images (ImageList): :class:`ImageList` instance representing N input images + pred_objectness_logits (list[Tensor]): A list of L elements. + Element i is a tensor of shape (N, A, Hi, Wi) representing + the predicted objectness logits for anchors. + pred_anchor_deltas (list[Tensor]): A list of L elements. Element i is a tensor of shape + (N, A*4, Hi, Wi) representing the predicted "deltas" used to transform anchors + to proposals. + anchors (list[list[Boxes]]): A list of N elements. Each element is a list of L + Boxes. The Boxes at (n, l) stores the entire anchor array for feature map l in image + n (i.e. the cell anchors repeated over all locations in feature map (n, l)). + boundary_threshold (int): if >= 0, then anchors that extend beyond the image + boundary by more than boundary_thresh are not used in training. Set to a very large + number or < 0 to disable this behavior. Only needed in training. + gt_boxes (list[Boxes], optional): A list of N elements. Element i a Boxes storing + the ground-truth ("gt") boxes for image i. + smooth_l1_beta (float): The transition point between L1 and L2 loss in + the smooth L1 loss function. When set to 0, the loss becomes L1. When + set to +inf, the loss becomes constant 0. + """ + self.box2box_transform = box2box_transform + self.anchor_matcher = anchor_matcher + self.batch_size_per_image = batch_size_per_image + self.positive_fraction = positive_fraction + self.pred_objectness_logits = pred_objectness_logits + self.pred_anchor_deltas = pred_anchor_deltas + + self.anchors = anchors + self.gt_boxes = gt_boxes + self.num_feature_maps = len(pred_objectness_logits) + self.num_images = len(images) + self.image_sizes = images.image_sizes + self.boundary_threshold = boundary_threshold + self.smooth_l1_beta = smooth_l1_beta + + def _get_ground_truth(self): + """ + Returns: + gt_objectness_logits: list of N tensors. Tensor i is a vector whose length is the + total number of anchors in image i (i.e., len(anchors[i])). Label values are + in {-1, 0, 1}, with meanings: -1 = ignore; 0 = negative class; 1 = positive class. + gt_anchor_deltas: list of N tensors. Tensor i has shape (len(anchors[i]), 4). + """ + gt_objectness_logits = [] + gt_anchor_deltas = [] + # Concatenate anchors from all feature maps into a single Boxes per image + anchors = [BUABoxes.cat(anchors_i) for anchors_i in self.anchors] + for image_size_i, anchors_i, gt_boxes_i in zip(self.image_sizes, anchors, self.gt_boxes): + """ + image_size_i: (h, w) for the i-th image + anchors_i: anchors for i-th image + gt_boxes_i: ground-truth boxes for i-th image + """ + match_quality_matrix = pairwise_iou(gt_boxes_i, anchors_i) + matched_idxs, gt_objectness_logits_i = self.anchor_matcher(match_quality_matrix) + + if self.boundary_threshold >= 0: + # Discard anchors that go out of the boundaries of the image + # NOTE: This is legacy functionality that is turned off by default in Detectron2 + anchors_inside_image = anchors_i.inside_box(image_size_i, self.boundary_threshold) + gt_objectness_logits_i[~anchors_inside_image] = -1 + + if len(gt_boxes_i) == 0: + # These values won't be used anyway since the anchor is labeled as background + gt_anchor_deltas_i = torch.zeros_like(anchors_i.tensor) + else: + # TODO wasted computation for ignored boxes + matched_gt_boxes = gt_boxes_i[matched_idxs] + gt_anchor_deltas_i = self.box2box_transform.get_deltas( + anchors_i.tensor, matched_gt_boxes.tensor + ) + + gt_objectness_logits.append(gt_objectness_logits_i) + gt_anchor_deltas.append(gt_anchor_deltas_i) + + return gt_objectness_logits, gt_anchor_deltas + + def losses(self): + """ + Return the losses from a set of RPN predictions and their associated ground-truth. + + Returns: + dict[loss name -> loss value]: A dict mapping from loss name to loss value. + Loss names are: `loss_rpn_cls` for objectness classification and + `loss_rpn_loc` for proposal localization. + """ + + def resample(label): + """ + Randomly sample a subset of positive and negative examples by overwriting + the label vector to the ignore value (-1) for all elements that are not + included in the sample. + """ + pos_idx, neg_idx = subsample_labels( + label, self.batch_size_per_image, self.positive_fraction, 0 + ) + # Fill with the ignore label (-1), then set positive and negative labels + label.fill_(-1) + label.scatter_(0, pos_idx, 1) + label.scatter_(0, neg_idx, 0) + return label + + gt_objectness_logits, gt_anchor_deltas = self._get_ground_truth() + """ + gt_objectness_logits: list of N tensors. Tensor i is a vector whose length is the + total number of anchors in image i (i.e., len(anchors[i])) + gt_anchor_deltas: list of N tensors. Tensor i has shape (len(anchors[i]), B), + where B is the box dimension + """ + # Collect all objectness labels and delta targets over feature maps and images + # The final ordering is L, N, H, W, A from slowest to fastest axis. + num_anchors_per_map = [int(np.prod(x.shape[1:])/2) for x in self.pred_objectness_logits] + num_anchors_per_image = sum(num_anchors_per_map) + + # Stack to: (N, num_anchors_per_image) + gt_objectness_logits = torch.stack( + [resample(label) for label in gt_objectness_logits], dim=0 + ) + + # Log the number of positive/negative anchors per-image that's used in training + num_pos_anchors = (gt_objectness_logits == 1).sum().item() + num_neg_anchors = (gt_objectness_logits == 0).sum().item() + storage = get_event_storage() + storage.put_scalar("rpn/num_pos_anchors", num_pos_anchors / self.num_images) + storage.put_scalar("rpn/num_neg_anchors", num_neg_anchors / self.num_images) + + assert gt_objectness_logits.shape[1] == num_anchors_per_image + # Split to tuple of L tensors, each with shape (N, num_anchors_per_map) + gt_objectness_logits = torch.split(gt_objectness_logits, num_anchors_per_map, dim=1) + # Concat from all feature maps + gt_objectness_logits = cat([x.flatten() for x in gt_objectness_logits], dim=0) + + # Stack to: (N, num_anchors_per_image, B) + gt_anchor_deltas = torch.stack(gt_anchor_deltas, dim=0) + assert gt_anchor_deltas.shape[1] == num_anchors_per_image + B = gt_anchor_deltas.shape[2] # box dimension (4 or 5) + + # Split to tuple of L tensors, each with shape (N, num_anchors_per_image) + gt_anchor_deltas = torch.split(gt_anchor_deltas, num_anchors_per_map, dim=1) + # Concat from all feature maps + gt_anchor_deltas = cat([x.reshape(-1, B) for x in gt_anchor_deltas], dim=0) + + # Collect all objectness logits and delta predictions over feature maps + # and images to arrive at the same shape as the labels and targets + # The final ordering is L, N, H, W, 2A from slowest to fastest axis. + pred_objectness_logits = cat( + [ + # Reshape: (N, 2A, Hi, Wi) -> (N, Hi, Wi, 2A) -> (N*Hi*Wi*A, 2) + x.permute(0, 2, 3, 1).reshape(-1, 2) + for x in self.pred_objectness_logits + ], + dim=0, + ) + pred_anchor_deltas = cat( + [ + # Reshape: (N, A*B, Hi, Wi) -> (N, A, B, Hi, Wi) -> (N, Hi, Wi, A, B) + # -> (N*Hi*Wi*A, B) + x.view(x.shape[0], -1, B, x.shape[-2], x.shape[-1]) + .permute(0, 3, 4, 1, 2) + .reshape(-1, B) + for x in self.pred_anchor_deltas + ], + dim=0, + ) + + objectness_loss, localization_loss = bua_rpn_losses( + gt_objectness_logits, + gt_anchor_deltas, + pred_objectness_logits, + pred_anchor_deltas, + self.smooth_l1_beta, + ) + normalizer = 1.0 / (self.batch_size_per_image * self.num_images) + loss_cls = objectness_loss * normalizer # cls: classification loss + loss_loc = localization_loss * normalizer # loc: localization loss + losses = {"loss_rpn_cls": loss_cls, "loss_rpn_loc": loss_loc} + + return losses + + def predict_proposals(self): + """ + Transform anchors into proposals by applying the predicted anchor deltas. + + Returns: + proposals (list[Tensor]): A list of L tensors. Tensor i has shape + (N, Hi*Wi*A, B), where B is box dimension (4 or 5). + """ + proposals = [] + # Transpose anchors from images-by-feature-maps (N, L) to feature-maps-by-images (L, N) + # anchors = list(zip(*self.anchors)) + anchors = list(zip(*[self.anchors])) + # For each feature map + for anchors_i, pred_anchor_deltas_i in zip(anchors, self.pred_anchor_deltas): + B = anchors_i[0].tensor.size(1) + N, _, Hi, Wi = pred_anchor_deltas_i.shape + # Reshape: (N, A*B, Hi, Wi) -> (N, A, B, Hi, Wi) -> (N, Hi, Wi, A, B) -> (N*Hi*Wi*A, B) + pred_anchor_deltas_i = ( + pred_anchor_deltas_i.view(N, -1, B, Hi, Wi).permute(0, 3, 4, 1, 2).reshape(-1, B) + ) + # Concatenate all anchors to shape (N*Hi*Wi*A, B) + # type(anchors_i[0]) is Boxes (B = 4) or RotatedBoxes (B = 5) + anchors_i = type(anchors_i[0]).cat(anchors_i) + proposals_i = self.box2box_transform.apply_deltas( + pred_anchor_deltas_i, anchors_i.tensor + ) + # Append feature map proposals with shape (N, Hi*Wi*A, B) + proposals.append(proposals_i.view(N, -1, B)) + return proposals + + def predict_objectness_logits(self): + """ + Return objectness logits in the same format as the proposals returned by + :meth:`predict_proposals`. + + Returns: + pred_objectness_logits (list[Tensor]): A list of L tensors. Tensor i has shape + (N, Hi*Wi*A). + """ + pred_objectness_logits = [ + # Reshape: (N, 2A, Hi, Wi) -> (N, 2, A, Hi, Wi) -> (N, Hi, Wi, 1, A) -> (N, Hi*Wi*A) + F.softmax(score.view(score.shape[0], 2, int(float(score.shape[1]) / float(2)), score.shape[2], score.shape[3]), dim=1)[:, 1:, :, :, :]\ + .permute(0, 3, 4, 1, 2).reshape(self.num_images, -1) + for score in self.pred_objectness_logits + ] + return pred_objectness_logits + + +def bua_rpn_losses( + gt_objectness_logits, + gt_anchor_deltas, + pred_objectness_logits, + pred_anchor_deltas, + smooth_l1_beta, +): + """ + Args: + gt_objectness_logits (Tensor): shape (N,), each element in {-1, 0, 1} representing + ground-truth objectness labels with: -1 = ignore; 0 = not object; 1 = object. + gt_anchor_deltas (Tensor): shape (N, box_dim), row i represents ground-truth + box2box transform targets (dx, dy, dw, dh) or (dx, dy, dw, dh, da) that map anchor i to + its matched ground-truth box. + pred_objectness_logits (Tensor): shape (N, 2), each element is a predicted objectness + logit. + pred_anchor_deltas (Tensor): shape (N, box_dim), each row is a predicted box2box + transform (dx, dy, dw, dh) or (dx, dy, dw, dh, da) + smooth_l1_beta (float): The transition point between L1 and L2 loss in + the smooth L1 loss function. When set to 0, the loss becomes L1. When + set to +inf, the loss becomes constant 0. + + Returns: + objectness_loss, localization_loss, both unnormalized (summed over samples). + """ + pos_masks = gt_objectness_logits == 1 + localization_loss = smooth_l1_loss( + pred_anchor_deltas[pos_masks], gt_anchor_deltas[pos_masks], smooth_l1_beta, reduction="sum" + ) + + valid_masks = gt_objectness_logits >= 0 + objectness_loss = F.cross_entropy( + pred_objectness_logits[valid_masks], + gt_objectness_logits[valid_masks].to(torch.long), + reduction="sum", + ) + return objectness_loss, localization_loss diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..04185530cf830905bc984948554bba2d203a9902 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/__init__.py @@ -0,0 +1 @@ +from .bua_utils import save_features diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/bua_utils.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/bua_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..d69562984e48c1b98df1d7704f251c799cb0e630 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/bua_utils.py @@ -0,0 +1,67 @@ +import os +import errno +import numpy as np +import torch + +from detectron2.structures import Instances +from detectron2.layers.nms import nms + +def save_features(output_file, features, boxes=None): + if boxes is None: + res = features + np.save(output_file, res) + else: + np.savez(output_file, x=features, bbox=boxes) + +def mkdir(path): + try: + os.makedirs(path) + except OSError as e: + if e.errno != errno.EEXIST: + raise + +def extractor_postprocess(boxes, scores, features_pooled, input_per_image, extractor): + """ + Resize the output instances. + The input images are often resized when entering an object detector. + As a result, we often need the outputs of the detector in a different + resolution from its inputs. + + This function will resize the raw outputs of an R-CNN detector + to produce outputs according to the desired output resolution. + + Args: + results (Instances): the raw outputs from the detector. + `results.image_size` contains the input image resolution the detector sees. + This object might be modified in-place. + output_height, output_width: the desired output resolution. + + Returns: + Instances: the resized output from the model, based on the output resolution + """ + MIN_BOXES = extractor.MIN_BOXES + MAX_BOXES = extractor.MAX_BOXES + CONF_THRESH = extractor.CONF_THRESH + + cur_device = scores.device + + dets = boxes / input_per_image["im_scale"] + + max_conf = torch.zeros((scores.shape[0])).to(cur_device) + + for cls_ind in range(1, scores.shape[1]): + cls_scores = scores[:, cls_ind] + keep = nms(dets, cls_scores, 0.3) + max_conf[keep] = torch.where(cls_scores[keep] > max_conf[keep], + cls_scores[keep], + max_conf[keep]) + + keep_boxes = torch.nonzero(max_conf >= CONF_THRESH).flatten() + if len(keep_boxes) < MIN_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MIN_BOXES] + elif len(keep_boxes) > MAX_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MAX_BOXES] + image_feat = features_pooled[keep_boxes] + image_bboxes = dets[keep_boxes] + + return image_feat, image_bboxes diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/extract_utils.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/extract_utils.py new file mode 100755 index 0000000000000000000000000000000000000000..455e401f976a9105f83e0050b85916f20a436f3c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/bbox_utils/extract_utils.py @@ -0,0 +1,183 @@ +import torch +import numpy as np +import cv2 +import os + +from detectron2.layers.nms import nms + +from ..bbox_models.bua.box_regression import BUABoxes + +PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]]) +TEST_SCALES = (600,) +TEST_MAX_SIZE = 1000 + +def im_list_to_blob(ims): + """Convert a list of images into a network input. + + Assumes images are already prepared (means subtracted, BGR order, ...). + """ + max_shape = np.array([im.shape for im in ims]).max(axis=0) + num_images = len(ims) + blob = np.zeros((num_images, max_shape[0], max_shape[1], 3), + dtype=np.float32) + for i in range(num_images): + im = ims[i] + blob[i, 0:im.shape[0], 0:im.shape[1], :] = im + + return blob + +def get_image_blob(im, pixel_means): + """Converts an image into a network input. + Arguments: + im (ndarray): a color image + Returns: + blob (ndarray): a data blob holding an image pyramid + im_scale_factors (list): list of image scales (relative to im) used + in the image pyramid + """ + pixel_means = np.array([[pixel_means]]) + dataset_dict = {} + im_orig = im.astype(np.float32, copy=True) + im_orig -= pixel_means + + im_shape = im_orig.shape + im_size_min = np.min(im_shape[0:2]) + im_size_max = np.max(im_shape[0:2]) + + for target_size in TEST_SCALES: + im_scale = float(target_size) / float(im_size_min) + # Prevent the biggest axis from being more than MAX_SIZE + if np.round(im_scale * im_size_max) > TEST_MAX_SIZE: + im_scale = float(TEST_MAX_SIZE) / float(im_size_max) + im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale, + interpolation=cv2.INTER_LINEAR) + + dataset_dict["image"] = torch.from_numpy(im).permute(2, 0, 1) + dataset_dict["im_scale"] = im_scale + + return dataset_dict + + +def save_roi_features(args, cfg, im_file, im, dataset_dict, boxes, scores, features_pooled, attr_scores=None): + MIN_BOXES = cfg.MODEL.BUA.EXTRACTOR.MIN_BOXES + MAX_BOXES = cfg.MODEL.BUA.EXTRACTOR.MAX_BOXES + CONF_THRESH = cfg.MODEL.BUA.EXTRACTOR.CONF_THRESH + + dets = boxes[0] / dataset_dict['im_scale'] + scores = scores[0] + feats = features_pooled[0] + + max_conf = torch.zeros((scores.shape[0])).to(scores.device) + for cls_ind in range(1, scores.shape[1]): + cls_scores = scores[:, cls_ind] + keep = nms(dets, cls_scores, 0.3) + max_conf[keep] = torch.where(cls_scores[keep] > max_conf[keep], + cls_scores[keep], + max_conf[keep]) + + keep_boxes = torch.nonzero(max_conf >= CONF_THRESH).flatten() + if len(keep_boxes) < MIN_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MIN_BOXES] + elif len(keep_boxes) > MAX_BOXES: + keep_boxes = torch.argsort(max_conf, descending=True)[:MAX_BOXES] + image_feat = feats[keep_boxes] + image_bboxes = dets[keep_boxes] + image_objects_conf = np.max(scores[keep_boxes].numpy()[:,1:], axis=1) + image_objects = np.argmax(scores[keep_boxes].numpy()[:,1:], axis=1) + if not attr_scores is None: + attr_scores = attr_scores[0] + image_attrs_conf = np.max(attr_scores[keep_boxes].numpy()[:,1:], axis=1) + image_attrs = np.argmax(attr_scores[keep_boxes].numpy()[:,1:], axis=1) + info = { + 'image_id': im_file.split('.')[0], + 'image_h': np.size(im, 0), + 'image_w': np.size(im, 1), + 'num_boxes': len(keep_boxes), + 'objects_id': image_objects, + 'objects_conf': image_objects_conf, + 'attrs_id': image_attrs, + 'attrs_conf': image_attrs_conf, + } + else: + info = { + 'image_id': im_file.split('.')[0], + 'image_h': np.size(im, 0), + 'image_w': np.size(im, 1), + 'num_boxes': len(keep_boxes), + 'objects_id': image_objects, + 'objects_conf': image_objects_conf + } + + output_file = os.path.join(args.output_dir, im_file.split('.')[0]) + np.savez_compressed(output_file, x=image_feat, bbox=image_bboxes, num_bbox=len(keep_boxes), image_h=np.size(im, 0), image_w=np.size(im, 1), info=info) + +def save_bbox(args, cfg, npz_dir, im_file, im, dataset_dict, boxes, scores): + MIN_BOXES = cfg.MODEL.BUA.EXTRACTOR.MIN_BOXES + MAX_BOXES = cfg.MODEL.BUA.EXTRACTOR.MAX_BOXES + CONF_THRESH = cfg.MODEL.BUA.EXTRACTOR.CONF_THRESH + + scores = scores[0] + boxes = boxes[0] + num_classes = scores.shape[1] + boxes = BUABoxes(boxes.reshape(-1, 4)) + boxes.clip((dataset_dict['image'].shape[1]/dataset_dict['im_scale'], dataset_dict['image'].shape[2]/dataset_dict['im_scale'])) + boxes = boxes.tensor.view(-1, num_classes*4) # R x C x 4 + + cls_boxes = torch.zeros((boxes.shape[0], 4)) + for idx in range(boxes.shape[0]): + cls_idx = torch.argmax(scores[idx, 1:]) + 1 + cls_boxes[idx, :] = boxes[idx, cls_idx * 4:(cls_idx + 1) * 4] + + max_conf = torch.zeros((scores.shape[0])).to(scores.device) + for cls_ind in range(1, num_classes): + cls_scores = scores[:, cls_ind] + keep = nms(cls_boxes, cls_scores, 0.3) + max_conf[keep] = torch.where(cls_scores[keep] > max_conf[keep], + cls_scores[keep], + max_conf[keep]) + + keep_boxes = torch.argsort(max_conf, descending=True)[:MAX_BOXES] + image_bboxes = cls_boxes[keep_boxes] + + output_file = os.path.join(npz_dir, im_file.split('.')[0]) + np.savez_compressed(output_file, bbox=image_bboxes, num_bbox=len(keep_boxes), image_h=np.size(im, 0), image_w=np.size(im, 1)) + +def save_roi_features_by_bbox(args, cfg, im_file, im, dataset_dict, boxes, scores, features_pooled, attr_scores=None): + MIN_BOXES = cfg.MODEL.BUA.EXTRACTOR.MIN_BOXES + MAX_BOXES = cfg.MODEL.BUA.EXTRACTOR.MAX_BOXES + CONF_THRESH = cfg.MODEL.BUA.EXTRACTOR.CONF_THRESH + dets = boxes[0] / dataset_dict['im_scale'] + scores = scores[0] + feats = features_pooled[0] + keep_boxes = [i for i in range(scores.shape[0])] + + image_feat = feats[keep_boxes] + image_bboxes = dets[keep_boxes] + image_objects_conf = np.max(scores[keep_boxes].numpy()[:,1:], axis=1) + image_objects = np.argmax(scores[keep_boxes].numpy()[:,1:], axis=1) + if not attr_scores is None: + attr_scores = attr_scores[0] + image_attrs_conf = np.max(attr_scores[keep_boxes].numpy()[:,1:], axis=1) + image_attrs = np.argmax(attr_scores[keep_boxes].numpy()[:,1:], axis=1) + info = { + 'image_id': im_file.split('.')[0], + 'image_h': np.size(im, 0), + 'image_w': np.size(im, 1), + 'num_boxes': len(keep_boxes), + 'objects_id': image_objects, + 'objects_conf': image_objects_conf, + 'attrs_id': image_attrs, + 'attrs_conf': image_attrs_conf, + } + else: + info = { + 'image_id': im_file.split('.')[0], + 'image_h': np.size(im, 0), + 'image_w': np.size(im, 1), + 'num_boxes': len(keep_boxes), + 'objects_id': image_objects, + 'objects_conf': image_objects_conf + } + + output_file = os.path.join(args.output_dir, im_file.split('.')[0]) + np.savez_compressed(output_file, x=image_feat, bbox=image_bboxes, num_bbox=len(keep_boxes), image_h=np.size(im, 0), image_w=np.size(im, 1), info=info) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml new file mode 100755 index 0000000000000000000000000000000000000000..28d9f35dd58558199ea80cec99f99185a0fd60a7 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml @@ -0,0 +1,53 @@ +MODEL: + DEVICE: 'cuda' + WEIGHTS: "/cfs/cfs-4a8cd28be/mmatch/infguo/weights/bua-caffe-frcn-r101_with_attributes.pth" + META_ARCHITECTURE: "GeneralizedBUARCNN" + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + ANCHOR_GENERATOR: + SIZES: [[4, 8, 16, 32]] + PROPOSAL_GENERATOR: + NAME: "BUARPN" + MIN_SIZE: 16 + BUA: + ATTRIBUTE_ON: True + EXTRACT_FEATS: True + RPN: + CONV_OUT_CHANNELS: 512 + EXTRACTOR: + MODE: 2 + MIN_BOXES: 5 + MAX_BOXES: 45 + CONF_THRESH: 0.4 + ATTRIBUTE: + NUM_CLASSES: 401 + RESNETS: + DEPTH: 101 + OUT_FEATURES: ["res4"] + NORM: "BN" + RES5_DILATION: 2 + BACKBONE: + NAME: "build_bua_resnet_backbone" + FREEZE_AT: 3 + RPN: + HEAD_NAME: "StandardBUARPNHead" + PRE_NMS_TOPK_TRAIN: 12000 + POST_NMS_TOPK_TRAIN: 2000 + POST_NMS_TOPK_TEST: 300 + PRE_NMS_TOPK_TEST: 6000 + BATCH_SIZE_PER_IMAGE: 64 + ROI_HEADS: + NAME: "BUACaffeRes5ROIHeads" + BATCH_SIZE_PER_IMAGE: 64 + SCORE_THRESH_TEST: -1.0 + NMS_THRESH_TEST: 0.3 + POSITIVE_FRACTION: 0.5 + NUM_CLASSES: 1601 + ROI_BOX_HEAD: + POOLER_TYPE: "ROIPool" + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) +INPUT: + MIN_SIZE_TRAIN: (600, ) + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MAX_SIZE_TEST: 1000 + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/config.yaml b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/config.yaml new file mode 100755 index 0000000000000000000000000000000000000000..026d955042fc2070c34a9ad6bc4a30a1b02ff2d7 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/config.yaml @@ -0,0 +1,317 @@ +CUDNN_BENCHMARK: false +DATALOADER: + ASPECT_RATIO_GROUPING: true + FILTER_EMPTY_ANNOTATIONS: true + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: [] + PROPOSAL_FILES_TRAIN: [] + TEST: [] + TRAIN: [] +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: false + SIZE: + - 0.9 + - 0.9 + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: + - 600 + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: + - - -90 + - 0 + - 90 + ASPECT_RATIOS: + - - 0.5 + - 1.0 + - 2.0 + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: + - - 4 + - 8 + - 16 + - 32 + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: true + CAFFE: true + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: true + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: '' + OUT_CHANNELS: 256 + KEYPOINT_ON: false + LOAD_PROPOSALS: false + MASK_ON: false + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: true + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: + - 102.9801 + - 115.9465 + - 122.7717 + PIXEL_STD: + - 1.0 + - 1.0 + - 1.0 + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: false + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: + - false + - false + - false + - false + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: + - res4 + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: true + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: + - p3 + - p4 + - p5 + - p6 + - p7 + IOU_LABELS: + - 0 + - -1 + - 1 + IOU_THRESHOLDS: + - 0.4 + - 0.5 + NMS_THRESH_TEST: 0.5 + NORM: '' + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: + - - 10.0 + - 10.0 + - 5.0 + - 5.0 + - - 20.0 + - 20.0 + - 10.0 + - 10.0 + - - 30.0 + - 30.0 + - 15.0 + - 15.0 + IOUS: + - 0.5 + - 0.6 + - 0.7 + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + CLS_AGNOSTIC_BBOX_REG: false + CONV_DIM: 256 + FC_DIM: 1024 + NAME: '' + NORM: '' + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: false + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: + - res4 + IOU_LABELS: + - 0 + - 1 + IOU_THRESHOLDS: + - 0.5 + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: true + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: true + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: false + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: '' + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: + - res4 + IOU_LABELS: + - 0 + - -1 + - 1 + IOU_THRESHOLDS: + - 0.3 + - 0.7 + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: + - p2 + - p3 + - p4 + - p5 + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: false + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: false + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: false + REFERENCE_WORLD_SIZE: 0 + STEPS: + - 30000 + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: false + FLIP: true + MAX_SIZE: 4000 + MIN_SIZES: + - 400 + - 500 + - 600 + - 700 + - 800 + - 900 + - 1000 + - 1100 + - 1200 + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: false + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/log.txt b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/log.txt new file mode 100755 index 0000000000000000000000000000000000000000..77d1750490a5e939c413e2809bf91276c194217e --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/bbox_extractor/output/log.txt @@ -0,0 +1,229573 @@ +[09/03 13:23:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 13:23:30] detectron2 INFO: Environment info: +---------------------- --------------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.0 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build True +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.10.0+cu102 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- --------------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 13:23:30] detectron2 INFO: Command line arguments: None +[09/03 13:23:30] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 13:23:30] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 13:23:30] d2.utils.env INFO: Using a generated random seed 30833344 +[09/03 13:23:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:23:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:23:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:23:36] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 13:24:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 13:24:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.0 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build True +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.0 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags /data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision/_C.so +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 13:24:57] detectron2 INFO: Command line arguments: None +[09/03 13:24:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 13:24:57] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 13:24:57] d2.utils.env INFO: Using a generated random seed 57093257 +[09/03 13:24:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:24:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:24:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:25:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 13:39:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 13:39:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 13:39:33] detectron2 INFO: Command line arguments: None +[09/03 13:39:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 13:39:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 13:39:33] d2.utils.env INFO: Using a generated random seed 33525286 +[09/03 13:39:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:39:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:39:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 13:39:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:20:52] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:20:52] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:20:52] detectron2 INFO: Command line arguments: None +[09/03 14:20:52] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:20:52] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:20:52] d2.utils.env INFO: Using a generated random seed 52827461 +[09/03 14:20:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:20:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:20:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:20:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:46:54] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:46:55] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:46:55] detectron2 INFO: Command line arguments: None +[09/03 14:46:55] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:46:55] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:46:55] d2.utils.env INFO: Using a generated random seed 55125752 +[09/03 14:46:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:46:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:46:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:01] detectron2 INFO: Command line arguments: None +[09/03 14:47:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:01] d2.utils.env INFO: Using a generated random seed 1738717 +[09/03 14:47:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:04] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:04] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:04] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:04] detectron2 INFO: Command line arguments: None +[09/03 14:47:04] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:04] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:04] d2.utils.env INFO: Using a generated random seed 4547919 +[09/03 14:47:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:06] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:06] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:07] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:07] detectron2 INFO: Command line arguments: None +[09/03 14:47:07] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:07] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:07] d2.utils.env INFO: Using a generated random seed 7189850 +[09/03 14:47:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:08] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:09] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:09] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:09] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:09] detectron2 INFO: Command line arguments: None +[09/03 14:47:09] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:09] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:09] d2.utils.env INFO: Using a generated random seed 9768793 +[09/03 14:47:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:11] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:11] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:12] detectron2 INFO: Command line arguments: None +[09/03 14:47:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:12] d2.utils.env INFO: Using a generated random seed 12287705 +[09/03 14:47:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:13] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:14] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:14] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:14] detectron2 INFO: Command line arguments: None +[09/03 14:47:14] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:14] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:14] d2.utils.env INFO: Using a generated random seed 14892963 +[09/03 14:47:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:17] detectron2 INFO: Command line arguments: None +[09/03 14:47:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:17] d2.utils.env INFO: Using a generated random seed 17559912 +[09/03 14:47:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:18] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:19] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:19] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:20] detectron2 INFO: Command line arguments: None +[09/03 14:47:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:20] d2.utils.env INFO: Using a generated random seed 20222714 +[09/03 14:47:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:22] detectron2 INFO: Command line arguments: None +[09/03 14:47:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:22] d2.utils.env INFO: Using a generated random seed 22830637 +[09/03 14:47:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:24] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:25] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:25] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:25] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:25] detectron2 INFO: Command line arguments: None +[09/03 14:47:25] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:25] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:25] d2.utils.env INFO: Using a generated random seed 25435980 +[09/03 14:47:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:27] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:28] detectron2 INFO: Command line arguments: None +[09/03 14:47:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:28] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:28] d2.utils.env INFO: Using a generated random seed 28148566 +[09/03 14:47:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:29] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:30] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:30] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:30] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:30] detectron2 INFO: Command line arguments: None +[09/03 14:47:30] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:30] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:30] d2.utils.env INFO: Using a generated random seed 30802608 +[09/03 14:47:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:32] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:33] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:33] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:33] detectron2 INFO: Command line arguments: None +[09/03 14:47:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:33] d2.utils.env INFO: Using a generated random seed 33420420 +[09/03 14:47:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:34] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:35] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:35] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:35] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:35] detectron2 INFO: Command line arguments: None +[09/03 14:47:35] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:35] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:35] d2.utils.env INFO: Using a generated random seed 35986645 +[09/03 14:47:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:37] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:38] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:38] detectron2 INFO: Command line arguments: None +[09/03 14:47:38] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:38] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:38] d2.utils.env INFO: Using a generated random seed 38602721 +[09/03 14:47:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:39] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:40] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:40] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:41] detectron2 INFO: Command line arguments: None +[09/03 14:47:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:41] d2.utils.env INFO: Using a generated random seed 41144795 +[09/03 14:47:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:42] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:43] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:43] detectron2 INFO: Command line arguments: None +[09/03 14:47:43] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:43] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:43] d2.utils.env INFO: Using a generated random seed 43782597 +[09/03 14:47:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:46] detectron2 INFO: Command line arguments: None +[09/03 14:47:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:46] d2.utils.env INFO: Using a generated random seed 46342126 +[09/03 14:47:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:48] detectron2 INFO: Command line arguments: None +[09/03 14:47:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:48] d2.utils.env INFO: Using a generated random seed 48974041 +[09/03 14:47:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:51] detectron2 INFO: Command line arguments: None +[09/03 14:47:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:51] d2.utils.env INFO: Using a generated random seed 51594846 +[09/03 14:47:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:54] detectron2 INFO: Command line arguments: None +[09/03 14:47:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:54] d2.utils.env INFO: Using a generated random seed 54207005 +[09/03 14:47:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:56] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:56] detectron2 INFO: Command line arguments: None +[09/03 14:47:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:56] d2.utils.env INFO: Using a generated random seed 56888546 +[09/03 14:47:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:58] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:47:58] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:47:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:47:59] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:47:59] detectron2 INFO: Command line arguments: None +[09/03 14:47:59] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:47:59] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:47:59] d2.utils.env INFO: Using a generated random seed 59276573 +[09/03 14:47:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:47:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:01] detectron2 INFO: Command line arguments: None +[09/03 14:48:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:01] d2.utils.env INFO: Using a generated random seed 1876075 +[09/03 14:48:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:04] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:04] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:04] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:04] detectron2 INFO: Command line arguments: None +[09/03 14:48:04] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:04] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:04] d2.utils.env INFO: Using a generated random seed 4569237 +[09/03 14:48:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:06] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:06] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:07] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:07] detectron2 INFO: Command line arguments: None +[09/03 14:48:07] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:07] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:07] d2.utils.env INFO: Using a generated random seed 7142131 +[09/03 14:48:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:08] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:09] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:09] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:09] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:09] detectron2 INFO: Command line arguments: None +[09/03 14:48:09] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:09] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:09] d2.utils.env INFO: Using a generated random seed 9822753 +[09/03 14:48:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:12] detectron2 INFO: Command line arguments: None +[09/03 14:48:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:12] d2.utils.env INFO: Using a generated random seed 12486850 +[09/03 14:48:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:13] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:14] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:15] detectron2 INFO: Command line arguments: None +[09/03 14:48:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:15] d2.utils.env INFO: Using a generated random seed 15203276 +[09/03 14:48:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:17] detectron2 INFO: Command line arguments: None +[09/03 14:48:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:17] d2.utils.env INFO: Using a generated random seed 17859941 +[09/03 14:48:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:20] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:20] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:20] detectron2 INFO: Command line arguments: None +[09/03 14:48:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:20] d2.utils.env INFO: Using a generated random seed 20548706 +[09/03 14:48:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:23] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:23] detectron2 INFO: Command line arguments: None +[09/03 14:48:23] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:23] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:23] d2.utils.env INFO: Using a generated random seed 23304932 +[09/03 14:48:23] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:23] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:23] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:24] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:25] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:25] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:25] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:25] detectron2 INFO: Command line arguments: None +[09/03 14:48:25] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:25] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:25] d2.utils.env INFO: Using a generated random seed 25830505 +[09/03 14:48:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:27] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:28] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:28] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:28] detectron2 INFO: Command line arguments: None +[09/03 14:48:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:28] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:28] d2.utils.env INFO: Using a generated random seed 28458302 +[09/03 14:48:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:29] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:30] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:30] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:31] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:31] detectron2 INFO: Command line arguments: None +[09/03 14:48:31] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:31] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:31] d2.utils.env INFO: Using a generated random seed 31127457 +[09/03 14:48:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:32] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:33] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:33] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:33] detectron2 INFO: Command line arguments: None +[09/03 14:48:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:33] d2.utils.env INFO: Using a generated random seed 33812024 +[09/03 14:48:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:36] detectron2 INFO: Command line arguments: None +[09/03 14:48:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:36] d2.utils.env INFO: Using a generated random seed 36452534 +[09/03 14:48:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:37] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:39] detectron2 INFO: Command line arguments: None +[09/03 14:48:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:39] d2.utils.env INFO: Using a generated random seed 39161734 +[09/03 14:48:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:41] detectron2 INFO: Command line arguments: None +[09/03 14:48:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:41] d2.utils.env INFO: Using a generated random seed 41776937 +[09/03 14:48:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:44] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:44] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:44] detectron2 INFO: Command line arguments: None +[09/03 14:48:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:44] d2.utils.env INFO: Using a generated random seed 44418747 +[09/03 14:48:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:47] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:47] detectron2 INFO: Command line arguments: None +[09/03 14:48:47] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:47] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:47] d2.utils.env INFO: Using a generated random seed 47069540 +[09/03 14:48:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:48] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:49] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:49] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:49] detectron2 INFO: Command line arguments: None +[09/03 14:48:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:49] d2.utils.env INFO: Using a generated random seed 49717310 +[09/03 14:48:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:51] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:52] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:52] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:52] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:52] detectron2 INFO: Command line arguments: None +[09/03 14:48:52] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:52] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:52] d2.utils.env INFO: Using a generated random seed 52405370 +[09/03 14:48:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:53] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:54] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:54] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:54] detectron2 INFO: Command line arguments: None +[09/03 14:48:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:54] d2.utils.env INFO: Using a generated random seed 54934270 +[09/03 14:48:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:56] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:57] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:57] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:48:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:48:57] detectron2 INFO: Command line arguments: None +[09/03 14:48:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:48:57] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:48:57] d2.utils.env INFO: Using a generated random seed 57649874 +[09/03 14:48:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:48:58] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:48:59] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:48:59] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:00] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:00] detectron2 INFO: Command line arguments: None +[09/03 14:49:00] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:00] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:00] d2.utils.env INFO: Using a generated random seed 211225 +[09/03 14:49:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:01] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:02] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:02] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:02] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:02] detectron2 INFO: Command line arguments: None +[09/03 14:49:02] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:02] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:02] d2.utils.env INFO: Using a generated random seed 2985949 +[09/03 14:49:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:04] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:05] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:05] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:05] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:05] detectron2 INFO: Command line arguments: None +[09/03 14:49:05] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:05] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:05] d2.utils.env INFO: Using a generated random seed 5722372 +[09/03 14:49:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:06] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:08] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:08] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:08] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:08] detectron2 INFO: Command line arguments: None +[09/03 14:49:08] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:08] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:08] d2.utils.env INFO: Using a generated random seed 8306794 +[09/03 14:49:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:09] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:10] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:10] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:10] detectron2 INFO: Command line arguments: None +[09/03 14:49:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:10] d2.utils.env INFO: Using a generated random seed 11004840 +[09/03 14:49:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:12] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:13] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:13] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:13] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:13] detectron2 INFO: Command line arguments: None +[09/03 14:49:13] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:13] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:13] d2.utils.env INFO: Using a generated random seed 13744644 +[09/03 14:49:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:15] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:16] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:16] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:16] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:16] detectron2 INFO: Command line arguments: None +[09/03 14:49:16] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:16] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:16] d2.utils.env INFO: Using a generated random seed 16409548 +[09/03 14:49:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:17] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:18] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:18] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:19] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:19] detectron2 INFO: Command line arguments: None +[09/03 14:49:19] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:19] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:19] d2.utils.env INFO: Using a generated random seed 19053610 +[09/03 14:49:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:20] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:21] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:21] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:21] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:21] detectron2 INFO: Command line arguments: None +[09/03 14:49:21] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:21] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:21] d2.utils.env INFO: Using a generated random seed 21681236 +[09/03 14:49:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:22] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:24] detectron2 INFO: Command line arguments: None +[09/03 14:49:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:24] d2.utils.env INFO: Using a generated random seed 24314434 +[09/03 14:49:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:26] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:27] detectron2 INFO: Command line arguments: None +[09/03 14:49:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:27] d2.utils.env INFO: Using a generated random seed 27041952 +[09/03 14:49:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:29] detectron2 INFO: Command line arguments: None +[09/03 14:49:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:29] d2.utils.env INFO: Using a generated random seed 29631286 +[09/03 14:49:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:32] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:32] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:32] detectron2 INFO: Command line arguments: None +[09/03 14:49:32] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:32] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:32] d2.utils.env INFO: Using a generated random seed 32332739 +[09/03 14:49:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:34] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:34] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:34] detectron2 INFO: Command line arguments: None +[09/03 14:49:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:34] d2.utils.env INFO: Using a generated random seed 34979304 +[09/03 14:49:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:36] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:37] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:37] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:37] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:37] detectron2 INFO: Command line arguments: None +[09/03 14:49:37] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:37] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:37] d2.utils.env INFO: Using a generated random seed 37536469 +[09/03 14:49:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:39] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:39] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:40] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:40] detectron2 INFO: Command line arguments: None +[09/03 14:49:40] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:40] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:40] d2.utils.env INFO: Using a generated random seed 40126679 +[09/03 14:49:40] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:40] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:40] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:41] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:42] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:42] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:42] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:42] detectron2 INFO: Command line arguments: None +[09/03 14:49:42] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:42] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:42] d2.utils.env INFO: Using a generated random seed 42809433 +[09/03 14:49:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:44] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:45] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:45] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:45] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:45] detectron2 INFO: Command line arguments: None +[09/03 14:49:45] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:45] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:45] d2.utils.env INFO: Using a generated random seed 45467401 +[09/03 14:49:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:46] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:47] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:47] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:48] detectron2 INFO: Command line arguments: None +[09/03 14:49:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:48] d2.utils.env INFO: Using a generated random seed 48129706 +[09/03 14:49:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:49] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:50] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:50] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:50] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:50] detectron2 INFO: Command line arguments: None +[09/03 14:49:50] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:50] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:50] d2.utils.env INFO: Using a generated random seed 50737990 +[09/03 14:49:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:51] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:53] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:53] detectron2 INFO: Command line arguments: None +[09/03 14:49:53] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:53] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:53] d2.utils.env INFO: Using a generated random seed 53425336 +[09/03 14:49:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:54] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:55] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:55] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:55] detectron2 INFO: Command line arguments: None +[09/03 14:49:55] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:55] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:55] d2.utils.env INFO: Using a generated random seed 56001670 +[09/03 14:49:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:49:58] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:49:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:49:58] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:49:58] detectron2 INFO: Command line arguments: None +[09/03 14:49:58] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:49:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:49:58] d2.utils.env INFO: Using a generated random seed 58657946 +[09/03 14:49:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:49:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:01] detectron2 INFO: Command line arguments: None +[09/03 14:50:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:01] d2.utils.env INFO: Using a generated random seed 1385208 +[09/03 14:50:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:03] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:03] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:03] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:03] detectron2 INFO: Command line arguments: None +[09/03 14:50:03] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:03] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:03] d2.utils.env INFO: Using a generated random seed 4068109 +[09/03 14:50:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:06] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:06] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:06] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:06] detectron2 INFO: Command line arguments: None +[09/03 14:50:06] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:06] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:06] d2.utils.env INFO: Using a generated random seed 6673187 +[09/03 14:50:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:07] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:08] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:08] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:09] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:09] detectron2 INFO: Command line arguments: None +[09/03 14:50:09] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:09] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:09] d2.utils.env INFO: Using a generated random seed 9214287 +[09/03 14:50:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:10] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:11] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:11] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:11] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:11] detectron2 INFO: Command line arguments: None +[09/03 14:50:11] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:11] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:11] d2.utils.env INFO: Using a generated random seed 11891377 +[09/03 14:50:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:13] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:14] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:14] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:14] detectron2 INFO: Command line arguments: None +[09/03 14:50:14] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:14] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:14] d2.utils.env INFO: Using a generated random seed 14575441 +[09/03 14:50:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:15] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:16] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:16] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:17] detectron2 INFO: Command line arguments: None +[09/03 14:50:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:17] d2.utils.env INFO: Using a generated random seed 17206823 +[09/03 14:50:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:18] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:19] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:19] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:19] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:19] detectron2 INFO: Command line arguments: None +[09/03 14:50:19] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:19] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:19] d2.utils.env INFO: Using a generated random seed 19840545 +[09/03 14:50:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:22] detectron2 INFO: Command line arguments: None +[09/03 14:50:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:22] d2.utils.env INFO: Using a generated random seed 22442997 +[09/03 14:50:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:23] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:25] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:25] detectron2 INFO: Command line arguments: None +[09/03 14:50:25] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:25] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:25] d2.utils.env INFO: Using a generated random seed 25107402 +[09/03 14:50:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:27] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:27] detectron2 INFO: Command line arguments: None +[09/03 14:50:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:27] d2.utils.env INFO: Using a generated random seed 27776725 +[09/03 14:50:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:29] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:30] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:30] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:30] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:30] detectron2 INFO: Command line arguments: None +[09/03 14:50:30] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:30] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:30] d2.utils.env INFO: Using a generated random seed 30412638 +[09/03 14:50:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:31] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:32] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:33] detectron2 INFO: Command line arguments: None +[09/03 14:50:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:33] d2.utils.env INFO: Using a generated random seed 33069036 +[09/03 14:50:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:34] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:35] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:35] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:35] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:35] detectron2 INFO: Command line arguments: None +[09/03 14:50:35] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:35] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:35] d2.utils.env INFO: Using a generated random seed 35629625 +[09/03 14:50:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:35] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:36] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:38] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:38] detectron2 INFO: Command line arguments: None +[09/03 14:50:38] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:38] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:38] d2.utils.env INFO: Using a generated random seed 38355663 +[09/03 14:50:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:39] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:40] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:40] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:40] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:40] detectron2 INFO: Command line arguments: None +[09/03 14:50:40] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:40] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:40] d2.utils.env INFO: Using a generated random seed 41047347 +[09/03 14:50:40] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:42] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:43] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:43] detectron2 INFO: Command line arguments: None +[09/03 14:50:43] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:43] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:43] d2.utils.env INFO: Using a generated random seed 43656752 +[09/03 14:50:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:44] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:45] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:45] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:46] detectron2 INFO: Command line arguments: None +[09/03 14:50:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:46] d2.utils.env INFO: Using a generated random seed 46247615 +[09/03 14:50:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:48] detectron2 INFO: Command line arguments: None +[09/03 14:50:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:48] d2.utils.env INFO: Using a generated random seed 48944079 +[09/03 14:50:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:51] detectron2 INFO: Command line arguments: None +[09/03 14:50:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:51] d2.utils.env INFO: Using a generated random seed 51600453 +[09/03 14:50:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:54] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:54] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:54] detectron2 INFO: Command line arguments: None +[09/03 14:50:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:54] d2.utils.env INFO: Using a generated random seed 54277258 +[09/03 14:50:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:56] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:56] detectron2 INFO: Command line arguments: None +[09/03 14:50:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:56] d2.utils.env INFO: Using a generated random seed 56905843 +[09/03 14:50:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:58] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:50:59] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:50:59] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:50:59] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:50:59] detectron2 INFO: Command line arguments: None +[09/03 14:50:59] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:50:59] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:50:59] d2.utils.env INFO: Using a generated random seed 59477861 +[09/03 14:50:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:50:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:02] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:02] detectron2 INFO: Command line arguments: None +[09/03 14:51:02] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:02] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:02] d2.utils.env INFO: Using a generated random seed 2105731 +[09/03 14:51:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:04] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:04] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:04] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:04] detectron2 INFO: Command line arguments: None +[09/03 14:51:04] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:04] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:04] d2.utils.env INFO: Using a generated random seed 4814378 +[09/03 14:51:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:06] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:07] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:07] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:07] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:07] detectron2 INFO: Command line arguments: None +[09/03 14:51:07] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:07] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:07] d2.utils.env INFO: Using a generated random seed 7445837 +[09/03 14:51:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:08] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:09] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:09] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:09] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:09] detectron2 INFO: Command line arguments: None +[09/03 14:51:09] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:10] d2.utils.env INFO: Using a generated random seed 10038845 +[09/03 14:51:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:12] detectron2 INFO: Command line arguments: None +[09/03 14:51:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:12] d2.utils.env INFO: Using a generated random seed 12648513 +[09/03 14:51:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:13] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:14] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:15] detectron2 INFO: Command line arguments: None +[09/03 14:51:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:15] d2.utils.env INFO: Using a generated random seed 15254862 +[09/03 14:51:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:17] detectron2 INFO: Command line arguments: None +[09/03 14:51:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:17] d2.utils.env INFO: Using a generated random seed 17928798 +[09/03 14:51:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/03 14:51:20] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/03 14:51:20] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/03 14:51:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.1.0 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/03 14:51:20] detectron2 INFO: Command line arguments: None +[09/03 14:51:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/03 14:51:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/03 14:51:20] d2.utils.env INFO: Using a generated random seed 20484172 +[09/03 14:51:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/03 14:51:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:17:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:17:59] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:17:59] detectron2 INFO: Command line arguments: None +[09/08 16:17:59] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:17:59] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:17:59] d2.utils.env INFO: Using a generated random seed 59482882 +[09/08 16:17:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:17:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:17:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:04] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:05] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:05] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:06] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:06] detectron2 INFO: Command line arguments: None +[09/08 16:18:06] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:06] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:06] d2.utils.env INFO: Using a generated random seed 6126313 +[09/08 16:18:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:07] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:08] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:08] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:08] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:08] detectron2 INFO: Command line arguments: None +[09/08 16:18:08] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:08] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:08] d2.utils.env INFO: Using a generated random seed 8540962 +[09/08 16:18:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:09] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:10] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:10] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:10] detectron2 INFO: Command line arguments: None +[09/08 16:18:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:10] d2.utils.env INFO: Using a generated random seed 10852680 +[09/08 16:18:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:12] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:13] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:13] detectron2 INFO: Command line arguments: None +[09/08 16:18:13] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:13] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:13] d2.utils.env INFO: Using a generated random seed 13182223 +[09/08 16:18:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:14] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:15] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:15] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:15] detectron2 INFO: Command line arguments: None +[09/08 16:18:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:15] d2.utils.env INFO: Using a generated random seed 15543562 +[09/08 16:18:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:17] detectron2 INFO: Command line arguments: None +[09/08 16:18:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:17] d2.utils.env INFO: Using a generated random seed 17882620 +[09/08 16:18:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:19] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:19] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:20] detectron2 INFO: Command line arguments: None +[09/08 16:18:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:20] d2.utils.env INFO: Using a generated random seed 20218291 +[09/08 16:18:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:22] detectron2 INFO: Command line arguments: None +[09/08 16:18:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:22] d2.utils.env INFO: Using a generated random seed 22573061 +[09/08 16:18:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:23] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:24] detectron2 INFO: Command line arguments: None +[09/08 16:18:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:24] d2.utils.env INFO: Using a generated random seed 24912167 +[09/08 16:18:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:26] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:27] detectron2 INFO: Command line arguments: None +[09/08 16:18:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:27] d2.utils.env INFO: Using a generated random seed 27302366 +[09/08 16:18:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:29] detectron2 INFO: Command line arguments: None +[09/08 16:18:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:29] d2.utils.env INFO: Using a generated random seed 29598188 +[09/08 16:18:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:31] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:31] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:31] detectron2 INFO: Command line arguments: None +[09/08 16:18:31] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:31] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:31] d2.utils.env INFO: Using a generated random seed 31950034 +[09/08 16:18:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:34] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:34] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:34] detectron2 INFO: Command line arguments: None +[09/08 16:18:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:34] d2.utils.env INFO: Using a generated random seed 34398855 +[09/08 16:18:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:36] detectron2 INFO: Command line arguments: None +[09/08 16:18:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:36] d2.utils.env INFO: Using a generated random seed 36968577 +[09/08 16:18:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:39] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:39] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:39] detectron2 INFO: Command line arguments: None +[09/08 16:18:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:39] d2.utils.env INFO: Using a generated random seed 39307591 +[09/08 16:18:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:41] detectron2 INFO: Command line arguments: None +[09/08 16:18:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:41] d2.utils.env INFO: Using a generated random seed 41877146 +[09/08 16:18:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:44] detectron2 INFO: Command line arguments: None +[09/08 16:18:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:44] d2.utils.env INFO: Using a generated random seed 44186943 +[09/08 16:18:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:46] detectron2 INFO: Command line arguments: None +[09/08 16:18:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:46] d2.utils.env INFO: Using a generated random seed 46621000 +[09/08 16:18:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:49] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:49] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:49] detectron2 INFO: Command line arguments: None +[09/08 16:18:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:49] d2.utils.env INFO: Using a generated random seed 49335755 +[09/08 16:18:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:51] detectron2 INFO: Command line arguments: None +[09/08 16:18:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:51] d2.utils.env INFO: Using a generated random seed 51744325 +[09/08 16:18:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:54] detectron2 INFO: Command line arguments: None +[09/08 16:18:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:54] d2.utils.env INFO: Using a generated random seed 54056142 +[09/08 16:18:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:56] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:56] detectron2 INFO: Command line arguments: None +[09/08 16:18:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:56] d2.utils.env INFO: Using a generated random seed 56410840 +[09/08 16:18:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:18:58] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:18:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:18:58] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:18:58] detectron2 INFO: Command line arguments: None +[09/08 16:18:58] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:18:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:18:58] d2.utils.env INFO: Using a generated random seed 58860805 +[09/08 16:18:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:18:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:00] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:00] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:01] detectron2 INFO: Command line arguments: None +[09/08 16:19:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:01] d2.utils.env INFO: Using a generated random seed 1225873 +[09/08 16:19:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:03] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:03] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:03] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:03] detectron2 INFO: Command line arguments: None +[09/08 16:19:03] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:03] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:03] d2.utils.env INFO: Using a generated random seed 3506101 +[09/08 16:19:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:04] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:05] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:05] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:05] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:05] detectron2 INFO: Command line arguments: None +[09/08 16:19:05] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:05] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:05] d2.utils.env INFO: Using a generated random seed 5852029 +[09/08 16:19:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:07] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:07] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:07] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:08] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:08] detectron2 INFO: Command line arguments: None +[09/08 16:19:08] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:08] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:08] d2.utils.env INFO: Using a generated random seed 8174499 +[09/08 16:19:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:09] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:10] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:10] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:10] detectron2 INFO: Command line arguments: None +[09/08 16:19:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:10] d2.utils.env INFO: Using a generated random seed 10516341 +[09/08 16:19:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:12] detectron2 INFO: Command line arguments: None +[09/08 16:19:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:12] d2.utils.env INFO: Using a generated random seed 12863666 +[09/08 16:19:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:14] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:15] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:15] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:15] detectron2 INFO: Command line arguments: None +[09/08 16:19:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:15] d2.utils.env INFO: Using a generated random seed 15489525 +[09/08 16:19:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:17] detectron2 INFO: Command line arguments: None +[09/08 16:19:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:17] d2.utils.env INFO: Using a generated random seed 18016882 +[09/08 16:19:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:20] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:20] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:20] detectron2 INFO: Command line arguments: None +[09/08 16:19:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:20] d2.utils.env INFO: Using a generated random seed 20584023 +[09/08 16:19:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:22] detectron2 INFO: Command line arguments: None +[09/08 16:19:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:22] d2.utils.env INFO: Using a generated random seed 22979873 +[09/08 16:19:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:24] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:25] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:25] detectron2 INFO: Command line arguments: None +[09/08 16:19:25] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:25] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:25] d2.utils.env INFO: Using a generated random seed 25306645 +[09/08 16:19:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:27] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:27] detectron2 INFO: Command line arguments: None +[09/08 16:19:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:27] d2.utils.env INFO: Using a generated random seed 27599964 +[09/08 16:19:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:29] detectron2 INFO: Command line arguments: None +[09/08 16:19:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:29] d2.utils.env INFO: Using a generated random seed 29953843 +[09/08 16:19:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:31] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:32] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:32] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:32] detectron2 INFO: Command line arguments: None +[09/08 16:19:32] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:32] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:32] d2.utils.env INFO: Using a generated random seed 32339962 +[09/08 16:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:34] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:34] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:34] detectron2 INFO: Command line arguments: None +[09/08 16:19:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:34] d2.utils.env INFO: Using a generated random seed 34698908 +[09/08 16:19:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:36] detectron2 INFO: Command line arguments: None +[09/08 16:19:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:36] d2.utils.env INFO: Using a generated random seed 36999682 +[09/08 16:19:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:39] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:39] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:39] detectron2 INFO: Command line arguments: None +[09/08 16:19:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:39] d2.utils.env INFO: Using a generated random seed 39533539 +[09/08 16:19:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:41] detectron2 INFO: Command line arguments: None +[09/08 16:19:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:41] d2.utils.env INFO: Using a generated random seed 41824394 +[09/08 16:19:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:44] detectron2 INFO: Command line arguments: None +[09/08 16:19:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:44] d2.utils.env INFO: Using a generated random seed 44176472 +[09/08 16:19:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:46] detectron2 INFO: Command line arguments: None +[09/08 16:19:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:46] d2.utils.env INFO: Using a generated random seed 46527268 +[09/08 16:19:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:48] detectron2 INFO: Command line arguments: None +[09/08 16:19:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:48] d2.utils.env INFO: Using a generated random seed 48946706 +[09/08 16:19:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:51] detectron2 INFO: Command line arguments: None +[09/08 16:19:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:51] d2.utils.env INFO: Using a generated random seed 51317442 +[09/08 16:19:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:53] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:53] detectron2 INFO: Command line arguments: None +[09/08 16:19:53] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:53] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:53] d2.utils.env INFO: Using a generated random seed 53844950 +[09/08 16:19:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:55] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:56] detectron2 INFO: Command line arguments: None +[09/08 16:19:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:56] d2.utils.env INFO: Using a generated random seed 56282710 +[09/08 16:19:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:19:58] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:19:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:19:58] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:19:58] detectron2 INFO: Command line arguments: None +[09/08 16:19:58] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:19:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:19:58] d2.utils.env INFO: Using a generated random seed 58866820 +[09/08 16:19:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:19:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:01] detectron2 INFO: Command line arguments: None +[09/08 16:20:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:01] d2.utils.env INFO: Using a generated random seed 1343303 +[09/08 16:20:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:03] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:03] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:03] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:03] detectron2 INFO: Command line arguments: None +[09/08 16:20:03] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:03] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:03] d2.utils.env INFO: Using a generated random seed 3793285 +[09/08 16:20:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:05] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:05] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:05] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:05] detectron2 INFO: Command line arguments: None +[09/08 16:20:05] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:05] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:05] d2.utils.env INFO: Using a generated random seed 6029527 +[09/08 16:20:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:07] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:08] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:08] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:08] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:08] detectron2 INFO: Command line arguments: None +[09/08 16:20:08] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:08] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:08] d2.utils.env INFO: Using a generated random seed 8394744 +[09/08 16:20:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:09] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:10] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:10] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:10] detectron2 INFO: Command line arguments: None +[09/08 16:20:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:10] d2.utils.env INFO: Using a generated random seed 10759824 +[09/08 16:20:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:12] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:12] detectron2 INFO: Command line arguments: None +[09/08 16:20:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:12] d2.utils.env INFO: Using a generated random seed 13057483 +[09/08 16:20:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:14] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:15] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:15] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:15] detectron2 INFO: Command line arguments: None +[09/08 16:20:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:15] d2.utils.env INFO: Using a generated random seed 15361993 +[09/08 16:20:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:17] detectron2 INFO: Command line arguments: None +[09/08 16:20:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:17] d2.utils.env INFO: Using a generated random seed 17862804 +[09/08 16:20:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:20] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:20] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:20] detectron2 INFO: Command line arguments: None +[09/08 16:20:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:20] d2.utils.env INFO: Using a generated random seed 20372617 +[09/08 16:20:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:22] detectron2 INFO: Command line arguments: None +[09/08 16:20:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:22] d2.utils.env INFO: Using a generated random seed 22719332 +[09/08 16:20:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:23] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:24] detectron2 INFO: Command line arguments: None +[09/08 16:20:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:24] d2.utils.env INFO: Using a generated random seed 25030526 +[09/08 16:20:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:27] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:27] detectron2 INFO: Command line arguments: None +[09/08 16:20:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:27] d2.utils.env INFO: Using a generated random seed 27376544 +[09/08 16:20:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:29] detectron2 INFO: Command line arguments: None +[09/08 16:20:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:29] d2.utils.env INFO: Using a generated random seed 29721654 +[09/08 16:20:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:31] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:32] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:32] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:32] detectron2 INFO: Command line arguments: None +[09/08 16:20:32] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:32] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:32] d2.utils.env INFO: Using a generated random seed 32411072 +[09/08 16:20:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:34] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:34] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:34] detectron2 INFO: Command line arguments: None +[09/08 16:20:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:34] d2.utils.env INFO: Using a generated random seed 34825613 +[09/08 16:20:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:36] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:37] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:37] detectron2 INFO: Command line arguments: None +[09/08 16:20:37] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:37] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:37] d2.utils.env INFO: Using a generated random seed 37243193 +[09/08 16:20:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:39] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:39] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:39] detectron2 INFO: Command line arguments: None +[09/08 16:20:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:39] d2.utils.env INFO: Using a generated random seed 39588651 +[09/08 16:20:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:42] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:42] detectron2 INFO: Command line arguments: None +[09/08 16:20:42] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:42] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:42] d2.utils.env INFO: Using a generated random seed 42105903 +[09/08 16:20:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:44] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:44] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:44] detectron2 INFO: Command line arguments: None +[09/08 16:20:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:44] d2.utils.env INFO: Using a generated random seed 44502419 +[09/08 16:20:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:46] detectron2 INFO: Command line arguments: None +[09/08 16:20:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:46] d2.utils.env INFO: Using a generated random seed 46939451 +[09/08 16:20:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:48] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:49] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:49] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:49] detectron2 INFO: Command line arguments: None +[09/08 16:20:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:49] d2.utils.env INFO: Using a generated random seed 49302932 +[09/08 16:20:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:51] detectron2 INFO: Command line arguments: None +[09/08 16:20:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:51] d2.utils.env INFO: Using a generated random seed 51663113 +[09/08 16:20:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:54] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:54] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:54] detectron2 INFO: Command line arguments: None +[09/08 16:20:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:54] d2.utils.env INFO: Using a generated random seed 54335656 +[09/08 16:20:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:56] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:56] detectron2 INFO: Command line arguments: None +[09/08 16:20:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:56] d2.utils.env INFO: Using a generated random seed 56654700 +[09/08 16:20:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:20:59] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:20:59] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:20:59] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:20:59] detectron2 INFO: Command line arguments: None +[09/08 16:20:59] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:20:59] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:20:59] d2.utils.env INFO: Using a generated random seed 59362886 +[09/08 16:20:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:20:59] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:01] detectron2 INFO: Command line arguments: None +[09/08 16:21:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:01] d2.utils.env INFO: Using a generated random seed 1957753 +[09/08 16:21:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:04] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:04] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:04] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:04] detectron2 INFO: Command line arguments: None +[09/08 16:21:04] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:04] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:04] d2.utils.env INFO: Using a generated random seed 4560929 +[09/08 16:21:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:06] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:06] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:06] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:06] detectron2 INFO: Command line arguments: None +[09/08 16:21:06] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:06] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:06] d2.utils.env INFO: Using a generated random seed 7002656 +[09/08 16:21:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:08] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:09] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:09] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:09] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:09] detectron2 INFO: Command line arguments: None +[09/08 16:21:09] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:09] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:09] d2.utils.env INFO: Using a generated random seed 9280553 +[09/08 16:21:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:09] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:10] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:11] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:11] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:11] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:11] detectron2 INFO: Command line arguments: None +[09/08 16:21:11] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:11] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:11] d2.utils.env INFO: Using a generated random seed 11675746 +[09/08 16:21:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:12] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:13] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:13] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:13] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:13] detectron2 INFO: Command line arguments: None +[09/08 16:21:13] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:13] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:13] d2.utils.env INFO: Using a generated random seed 14036865 +[09/08 16:21:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:15] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:16] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:16] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:16] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:16] detectron2 INFO: Command line arguments: None +[09/08 16:21:16] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:16] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:16] d2.utils.env INFO: Using a generated random seed 16693342 +[09/08 16:21:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:17] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:19] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:19] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:19] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:19] detectron2 INFO: Command line arguments: None +[09/08 16:21:19] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:19] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:19] d2.utils.env INFO: Using a generated random seed 19370380 +[09/08 16:21:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:20] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:21] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:21] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:21] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:21] detectron2 INFO: Command line arguments: None +[09/08 16:21:21] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:21] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:21] d2.utils.env INFO: Using a generated random seed 22047435 +[09/08 16:21:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:23] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/08 16:21:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/08 16:21:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/08 16:21:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/08 16:21:24] detectron2 INFO: Command line arguments: None +[09/08 16:21:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/08 16:21:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/08 16:21:24] d2.utils.env INFO: Using a generated random seed 24651220 +[09/08 16:21:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/08 16:21:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:13] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:20] detectron2 INFO: Command line arguments: None +[09/12 16:14:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:20] d2.utils.env INFO: Using a generated random seed 20540862 +[09/12 16:14:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:26] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:26] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:26] detectron2 INFO: Command line arguments: None +[09/12 16:14:26] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:26] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:26] d2.utils.env INFO: Using a generated random seed 27000631 +[09/12 16:14:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:29] detectron2 INFO: Command line arguments: None +[09/12 16:14:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:29] d2.utils.env INFO: Using a generated random seed 29394872 +[09/12 16:14:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:31] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:31] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:31] detectron2 INFO: Command line arguments: None +[09/12 16:14:31] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:31] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:31] d2.utils.env INFO: Using a generated random seed 31833574 +[09/12 16:14:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:33] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:33] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:34] detectron2 INFO: Command line arguments: None +[09/12 16:14:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:34] d2.utils.env INFO: Using a generated random seed 34155468 +[09/12 16:14:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:36] detectron2 INFO: Command line arguments: None +[09/12 16:14:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:36] d2.utils.env INFO: Using a generated random seed 36533255 +[09/12 16:14:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:37] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:38] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:38] detectron2 INFO: Command line arguments: None +[09/12 16:14:38] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:38] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:38] d2.utils.env INFO: Using a generated random seed 38849929 +[09/12 16:14:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:40] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:40] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:41] detectron2 INFO: Command line arguments: None +[09/12 16:14:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:41] d2.utils.env INFO: Using a generated random seed 41187110 +[09/12 16:14:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:42] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:43] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:43] detectron2 INFO: Command line arguments: None +[09/12 16:14:43] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:43] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:43] d2.utils.env INFO: Using a generated random seed 43617952 +[09/12 16:14:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:44] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:45] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:45] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:45] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:45] detectron2 INFO: Command line arguments: None +[09/12 16:14:45] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:45] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:45] d2.utils.env INFO: Using a generated random seed 45998531 +[09/12 16:14:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:45] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:48] detectron2 INFO: Command line arguments: None +[09/12 16:14:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:48] d2.utils.env INFO: Using a generated random seed 48307474 +[09/12 16:14:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:49] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:50] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:50] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:50] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:50] detectron2 INFO: Command line arguments: None +[09/12 16:14:50] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:50] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:50] d2.utils.env INFO: Using a generated random seed 50657327 +[09/12 16:14:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:51] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:52] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:52] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:52] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:52] detectron2 INFO: Command line arguments: None +[09/12 16:14:52] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:52] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:52] d2.utils.env INFO: Using a generated random seed 52970988 +[09/12 16:14:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:52] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:54] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:55] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:55] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:55] detectron2 INFO: Command line arguments: None +[09/12 16:14:55] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:55] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:55] d2.utils.env INFO: Using a generated random seed 55407226 +[09/12 16:14:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:56] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:14:57] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:14:57] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:14:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:14:57] detectron2 INFO: Command line arguments: None +[09/12 16:14:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:14:57] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:14:57] d2.utils.env INFO: Using a generated random seed 57987311 +[09/12 16:14:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:14:59] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:00] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:00] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:00] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:00] detectron2 INFO: Command line arguments: None +[09/12 16:15:00] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:00] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:00] d2.utils.env INFO: Using a generated random seed 309319 +[09/12 16:15:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:01] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:02] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:02] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:02] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:02] detectron2 INFO: Command line arguments: None +[09/12 16:15:02] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:02] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:02] d2.utils.env INFO: Using a generated random seed 2849165 +[09/12 16:15:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:02] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:04] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:04] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:04] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:05] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:05] detectron2 INFO: Command line arguments: None +[09/12 16:15:05] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:05] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:05] d2.utils.env INFO: Using a generated random seed 5134967 +[09/12 16:15:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:06] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:07] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:07] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:07] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:07] detectron2 INFO: Command line arguments: None +[09/12 16:15:07] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:07] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:07] d2.utils.env INFO: Using a generated random seed 7578475 +[09/12 16:15:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:08] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:09] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:09] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:10] detectron2 INFO: Command line arguments: None +[09/12 16:15:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:10] d2.utils.env INFO: Using a generated random seed 10231675 +[09/12 16:15:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:12] detectron2 INFO: Command line arguments: None +[09/12 16:15:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:12] d2.utils.env INFO: Using a generated random seed 12680592 +[09/12 16:15:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:13] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:14] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:15] detectron2 INFO: Command line arguments: None +[09/12 16:15:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:15] d2.utils.env INFO: Using a generated random seed 15095059 +[09/12 16:15:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:17] detectron2 INFO: Command line arguments: None +[09/12 16:15:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:17] d2.utils.env INFO: Using a generated random seed 17467929 +[09/12 16:15:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:18] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:19] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:19] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:19] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:19] detectron2 INFO: Command line arguments: None +[09/12 16:15:19] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:19] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:19] d2.utils.env INFO: Using a generated random seed 19956009 +[09/12 16:15:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:19] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:21] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:21] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:22] detectron2 INFO: Command line arguments: None +[09/12 16:15:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:22] d2.utils.env INFO: Using a generated random seed 22286204 +[09/12 16:15:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:23] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:24] detectron2 INFO: Command line arguments: None +[09/12 16:15:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:24] d2.utils.env INFO: Using a generated random seed 24628533 +[09/12 16:15:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:26] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:26] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:26] detectron2 INFO: Command line arguments: None +[09/12 16:15:26] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:26] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:26] d2.utils.env INFO: Using a generated random seed 26965641 +[09/12 16:15:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:28] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:29] detectron2 INFO: Command line arguments: None +[09/12 16:15:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:29] d2.utils.env INFO: Using a generated random seed 29304265 +[09/12 16:15:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:31] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:31] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:31] detectron2 INFO: Command line arguments: None +[09/12 16:15:31] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:31] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:31] d2.utils.env INFO: Using a generated random seed 31624689 +[09/12 16:15:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:32] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:33] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:33] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:33] detectron2 INFO: Command line arguments: None +[09/12 16:15:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:33] d2.utils.env INFO: Using a generated random seed 34001580 +[09/12 16:15:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:36] detectron2 INFO: Command line arguments: None +[09/12 16:15:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:36] d2.utils.env INFO: Using a generated random seed 36608972 +[09/12 16:15:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:37] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:39] detectron2 INFO: Command line arguments: None +[09/12 16:15:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:39] d2.utils.env INFO: Using a generated random seed 39176216 +[09/12 16:15:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:41] detectron2 INFO: Command line arguments: None +[09/12 16:15:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:41] d2.utils.env INFO: Using a generated random seed 41711312 +[09/12 16:15:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:43] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:44] detectron2 INFO: Command line arguments: None +[09/12 16:15:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:44] d2.utils.env INFO: Using a generated random seed 44137361 +[09/12 16:15:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:46] detectron2 INFO: Command line arguments: None +[09/12 16:15:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:46] d2.utils.env INFO: Using a generated random seed 46489263 +[09/12 16:15:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:47] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:48] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:48] detectron2 INFO: Command line arguments: None +[09/12 16:15:48] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:48] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:48] d2.utils.env INFO: Using a generated random seed 48863955 +[09/12 16:15:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:48] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:50] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:50] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:51] detectron2 INFO: Command line arguments: None +[09/12 16:15:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:51] d2.utils.env INFO: Using a generated random seed 51256906 +[09/12 16:15:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:53] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:53] detectron2 INFO: Command line arguments: None +[09/12 16:15:53] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:53] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:53] d2.utils.env INFO: Using a generated random seed 53574960 +[09/12 16:15:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:53] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:54] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:55] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:55] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:55] detectron2 INFO: Command line arguments: None +[09/12 16:15:55] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:55] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:55] d2.utils.env INFO: Using a generated random seed 55945536 +[09/12 16:15:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:55] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:15:57] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:15:57] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:15:58] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:15:58] detectron2 INFO: Command line arguments: None +[09/12 16:15:58] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:15:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:15:58] d2.utils.env INFO: Using a generated random seed 58245915 +[09/12 16:15:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:15:59] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:00] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:00] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:00] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:00] detectron2 INFO: Command line arguments: None +[09/12 16:16:00] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:00] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:00] d2.utils.env INFO: Using a generated random seed 811387 +[09/12 16:16:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:02] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:02] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:03] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:03] detectron2 INFO: Command line arguments: None +[09/12 16:16:03] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:03] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:03] d2.utils.env INFO: Using a generated random seed 3172878 +[09/12 16:16:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:04] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:05] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:05] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:05] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:05] detectron2 INFO: Command line arguments: None +[09/12 16:16:05] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:05] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:05] d2.utils.env INFO: Using a generated random seed 5594750 +[09/12 16:16:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:05] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:06] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:07] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:07] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:07] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:07] detectron2 INFO: Command line arguments: None +[09/12 16:16:07] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:07] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:07] d2.utils.env INFO: Using a generated random seed 8041995 +[09/12 16:16:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:07] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:09] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:10] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:10] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:10] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:10] detectron2 INFO: Command line arguments: None +[09/12 16:16:10] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:10] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:10] d2.utils.env INFO: Using a generated random seed 10494230 +[09/12 16:16:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:10] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:11] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:12] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:12] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:12] detectron2 INFO: Command line arguments: None +[09/12 16:16:12] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:12] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:12] d2.utils.env INFO: Using a generated random seed 12866002 +[09/12 16:16:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:12] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:14] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:15] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:15] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:15] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:15] detectron2 INFO: Command line arguments: None +[09/12 16:16:15] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:15] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:15] d2.utils.env INFO: Using a generated random seed 15369850 +[09/12 16:16:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:15] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:16] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:17] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:17] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:17] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:17] detectron2 INFO: Command line arguments: None +[09/12 16:16:17] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:17] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:17] d2.utils.env INFO: Using a generated random seed 17759668 +[09/12 16:16:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:17] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:20] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:20] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:20] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:20] detectron2 INFO: Command line arguments: None +[09/12 16:16:20] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:20] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:20] d2.utils.env INFO: Using a generated random seed 20436967 +[09/12 16:16:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:20] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:22] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:22] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:22] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:22] detectron2 INFO: Command line arguments: None +[09/12 16:16:22] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:22] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:22] d2.utils.env INFO: Using a generated random seed 22889406 +[09/12 16:16:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:22] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:24] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:25] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:25] detectron2 INFO: Command line arguments: None +[09/12 16:16:25] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:25] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:25] d2.utils.env INFO: Using a generated random seed 25280793 +[09/12 16:16:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:25] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:27] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:27] detectron2 INFO: Command line arguments: None +[09/12 16:16:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:27] d2.utils.env INFO: Using a generated random seed 27577802 +[09/12 16:16:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:29] detectron2 INFO: Command line arguments: None +[09/12 16:16:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:30] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:30] d2.utils.env INFO: Using a generated random seed 30092183 +[09/12 16:16:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:30] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:31] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:32] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:32] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:32] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:32] detectron2 INFO: Command line arguments: None +[09/12 16:16:32] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:32] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:32] d2.utils.env INFO: Using a generated random seed 32464961 +[09/12 16:16:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:34] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:34] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:34] detectron2 INFO: Command line arguments: None +[09/12 16:16:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:34] d2.utils.env INFO: Using a generated random seed 34774928 +[09/12 16:16:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:36] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:37] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:37] detectron2 INFO: Command line arguments: None +[09/12 16:16:37] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:37] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:37] d2.utils.env INFO: Using a generated random seed 37140132 +[09/12 16:16:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:38] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:39] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:39] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:39] detectron2 INFO: Command line arguments: None +[09/12 16:16:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:39] d2.utils.env INFO: Using a generated random seed 39654042 +[09/12 16:16:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:42] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:42] detectron2 INFO: Command line arguments: None +[09/12 16:16:42] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:42] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:42] d2.utils.env INFO: Using a generated random seed 42127393 +[09/12 16:16:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:42] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:44] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:44] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:44] detectron2 INFO: Command line arguments: None +[09/12 16:16:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:44] d2.utils.env INFO: Using a generated random seed 44448505 +[09/12 16:16:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:46] detectron2 INFO: Command line arguments: None +[09/12 16:16:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:46] d2.utils.env INFO: Using a generated random seed 46800927 +[09/12 16:16:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:48] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:48] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:48] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:49] detectron2 INFO: Command line arguments: None +[09/12 16:16:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:49] d2.utils.env INFO: Using a generated random seed 49155740 +[09/12 16:16:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:51] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:51] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:51] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:51] detectron2 INFO: Command line arguments: None +[09/12 16:16:51] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:51] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:51] d2.utils.env INFO: Using a generated random seed 51509970 +[09/12 16:16:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:51] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:52] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:53] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:53] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:54] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:54] detectron2 INFO: Command line arguments: None +[09/12 16:16:54] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:54] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:54] d2.utils.env INFO: Using a generated random seed 54164623 +[09/12 16:16:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:54] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:56] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:56] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:56] detectron2 INFO: Command line arguments: None +[09/12 16:16:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:56] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:56] d2.utils.env INFO: Using a generated random seed 56597479 +[09/12 16:16:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:57] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:16:58] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:16:58] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:16:58] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:16:58] detectron2 INFO: Command line arguments: None +[09/12 16:16:58] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:16:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:16:58] d2.utils.env INFO: Using a generated random seed 58946281 +[09/12 16:16:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:16:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:00] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:01] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:01] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:01] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:01] detectron2 INFO: Command line arguments: None +[09/12 16:17:01] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:01] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:01] d2.utils.env INFO: Using a generated random seed 1351444 +[09/12 16:17:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:01] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:03] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:03] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:03] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:03] detectron2 INFO: Command line arguments: None +[09/12 16:17:03] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:03] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:03] d2.utils.env INFO: Using a generated random seed 4059585 +[09/12 16:17:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:03] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:04] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:05] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:06] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:06] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:06] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:06] detectron2 INFO: Command line arguments: None +[09/12 16:17:06] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:06] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:06] d2.utils.env INFO: Using a generated random seed 6445150 +[09/12 16:17:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:06] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:07] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:08] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:08] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:08] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:08] detectron2 INFO: Command line arguments: None +[09/12 16:17:08] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:08] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:08] d2.utils.env INFO: Using a generated random seed 8974720 +[09/12 16:17:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:08] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:10] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:11] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:11] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:11] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:11] detectron2 INFO: Command line arguments: None +[09/12 16:17:11] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:11] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:11] d2.utils.env INFO: Using a generated random seed 11337961 +[09/12 16:17:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:11] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:12] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:13] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:13] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:13] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:13] detectron2 INFO: Command line arguments: None +[09/12 16:17:13] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:13] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:13] d2.utils.env INFO: Using a generated random seed 13669011 +[09/12 16:17:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:13] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:14] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:16] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:16] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:16] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:16] detectron2 INFO: Command line arguments: None +[09/12 16:17:16] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:16] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:16] d2.utils.env INFO: Using a generated random seed 16372982 +[09/12 16:17:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:17] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:18] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:18] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:18] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:18] detectron2 INFO: Command line arguments: None +[09/12 16:17:18] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:18] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:18] d2.utils.env INFO: Using a generated random seed 18694271 +[09/12 16:17:18] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:18] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:18] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:21] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:21] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:21] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:21] detectron2 INFO: Command line arguments: None +[09/12 16:17:21] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:21] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:21] d2.utils.env INFO: Using a generated random seed 21404755 +[09/12 16:17:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:22] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:24] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:24] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:24] detectron2 INFO: Command line arguments: None +[09/12 16:17:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:24] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:24] d2.utils.env INFO: Using a generated random seed 24383729 +[09/12 16:17:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:26] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:26] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:26] detectron2 INFO: Command line arguments: None +[09/12 16:17:26] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:26] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:26] d2.utils.env INFO: Using a generated random seed 27011713 +[09/12 16:17:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:26] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:28] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:29] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:29] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:29] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:29] detectron2 INFO: Command line arguments: None +[09/12 16:17:29] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:29] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:29] d2.utils.env INFO: Using a generated random seed 29435345 +[09/12 16:17:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:31] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:31] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:31] detectron2 INFO: Command line arguments: None +[09/12 16:17:31] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:31] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:31] d2.utils.env INFO: Using a generated random seed 31781544 +[09/12 16:17:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:31] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:33] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:33] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:34] detectron2 INFO: Command line arguments: None +[09/12 16:17:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:34] d2.utils.env INFO: Using a generated random seed 34101411 +[09/12 16:17:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:35] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:36] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:36] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:36] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:36] detectron2 INFO: Command line arguments: None +[09/12 16:17:36] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:36] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:36] d2.utils.env INFO: Using a generated random seed 36498593 +[09/12 16:17:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:36] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:37] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:38] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:38] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:39] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:39] detectron2 INFO: Command line arguments: None +[09/12 16:17:39] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:39] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:39] d2.utils.env INFO: Using a generated random seed 39221637 +[09/12 16:17:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:39] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:40] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:41] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:41] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:41] detectron2 INFO: Command line arguments: None +[09/12 16:17:41] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:41] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:41] d2.utils.env INFO: Using a generated random seed 41910281 +[09/12 16:17:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:41] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:43] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:44] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:44] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:44] detectron2 INFO: Command line arguments: None +[09/12 16:17:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:44] d2.utils.env INFO: Using a generated random seed 44576417 +[09/12 16:17:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:45] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:17:46] d2.config.compat WARNING: Config 'configs/bua-caffe/extract-bua-caffe-r101.yaml' has no VERSION. Assuming it to be compatible with latest v2. +[09/12 16:17:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:17:47] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:17:47] detectron2 INFO: Command line arguments: None +[09/12 16:17:47] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:17:47] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:17:47] d2.utils.env INFO: Using a generated random seed 47263625 +[09/12 16:17:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:47] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:17:48] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:24:44] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:24:46] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:24:46] detectron2 INFO: Command line arguments: None +[09/12 16:24:46] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:24:46] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:24:46] d2.utils.env INFO: Using a generated random seed 46775874 +[09/12 16:24:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:24:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:24:46] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:24:51] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:25:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:25:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:25:57] detectron2 INFO: Command line arguments: None +[09/12 16:25:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:25:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:25:58] d2.utils.env INFO: Using a generated random seed 58096359 +[09/12 16:25:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:25:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:25:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:26:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:28:35] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:28:37] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:28:37] detectron2 INFO: Command line arguments: None +[09/12 16:28:37] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:28:37] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:28:37] d2.utils.env INFO: Using a generated random seed 37636712 +[09/12 16:28:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:28:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:28:37] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:28:42] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 16:29:14] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 16:29:16] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 16:29:16] detectron2 INFO: Command line arguments: None +[09/12 16:29:16] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 16:29:16] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 16:29:16] d2.utils.env INFO: Using a generated random seed 16798131 +[09/12 16:29:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:29:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:29:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 16:29:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:29:18] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:29:21] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:29:21] detectron2 INFO: Command line arguments: None +[09/12 21:29:21] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:29:21] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:29:21] d2.utils.env INFO: Using a generated random seed 21161091 +[09/12 21:29:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:21] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:26] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:29:46] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:29:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:29:49] detectron2 INFO: Command line arguments: None +[09/12 21:29:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:29:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:29:49] d2.utils.env INFO: Using a generated random seed 49489264 +[09/12 21:29:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:29:54] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:33:12] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:33:14] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:33:14] detectron2 INFO: Command line arguments: None +[09/12 21:33:14] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:33:14] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:33:14] d2.utils.env INFO: Using a generated random seed 14673768 +[09/12 21:33:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:33:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:33:14] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:33:19] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:38:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:38:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:38:28] detectron2 INFO: Command line arguments: None +[09/12 21:38:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:38:28] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:38:28] d2.utils.env INFO: Using a generated random seed 29006570 +[09/12 21:38:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:38:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:38:29] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:38:34] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:42:54] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:42:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:42:57] detectron2 INFO: Command line arguments: None +[09/12 21:42:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:42:57] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:42:57] d2.utils.env INFO: Using a generated random seed 57145417 +[09/12 21:42:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:42:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:42:57] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:43:02] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:44:41] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:44:43] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:44:43] detectron2 INFO: Command line arguments: None +[09/12 21:44:43] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:44:43] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:44:43] d2.utils.env INFO: Using a generated random seed 43502337 +[09/12 21:44:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:44:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:44:43] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:44:48] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/12 21:53:25] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/12 21:53:27] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/12 21:53:27] detectron2 INFO: Command line arguments: None +[09/12 21:53:27] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/12 21:53:27] detectron2 INFO: Full config saved to ./output/config.yaml +[09/12 21:53:27] d2.utils.env INFO: Using a generated random seed 27714527 +[09/12 21:53:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:53:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:53:27] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/12 21:53:32] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 10:22:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 10:22:33] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 10:22:33] detectron2 INFO: Command line arguments: None +[09/13 10:22:33] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 10:22:33] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 10:22:33] d2.utils.env INFO: Using a generated random seed 33961806 +[09/13 10:22:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:22:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:22:33] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:22:39] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 10:36:26] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 10:36:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 10:36:28] detectron2 INFO: Command line arguments: None +[09/13 10:36:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 10:36:28] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 10:36:28] d2.utils.env INFO: Using a generated random seed 28754642 +[09/13 10:36:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:36:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:36:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:36:33] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 10:37:43] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 10:37:44] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 10:37:44] detectron2 INFO: Command line arguments: None +[09/13 10:37:44] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 10:37:44] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 10:37:44] d2.utils.env INFO: Using a generated random seed 44975601 +[09/13 10:37:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:37:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:37:44] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 10:37:50] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 12:26:47] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 12:26:49] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 12:26:49] detectron2 INFO: Command line arguments: None +[09/13 12:26:49] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 12:26:49] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 12:26:49] d2.utils.env INFO: Using a generated random seed 49709295 +[09/13 12:26:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:26:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:26:49] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:26:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 12:27:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 12:27:34] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 12:27:34] detectron2 INFO: Command line arguments: None +[09/13 12:27:34] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 12:27:34] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 12:27:34] d2.utils.env INFO: Using a generated random seed 34130381 +[09/13 12:27:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:27:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:27:34] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 12:27:39] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 14:52:49] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 14:52:50] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 14:52:50] detectron2 INFO: Command line arguments: None +[09/13 14:52:50] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 14:52:50] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 14:52:50] d2.utils.env INFO: Using a generated random seed 50133611 +[09/13 14:52:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:52:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:52:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:52:55] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 14:53:15] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 14:53:16] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 14:53:16] detectron2 INFO: Command line arguments: None +[09/13 14:53:16] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 14:53:16] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 14:53:16] d2.utils.env INFO: Using a generated random seed 16132496 +[09/13 14:53:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:53:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:53:16] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:53:21] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[09/13 14:54:57] detectron2 INFO: Rank of current process: 0. World size: 1 +[09/13 14:54:57] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[09/13 14:54:57] detectron2 INFO: Command line arguments: None +[09/13 14:54:57] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[09/13 14:54:58] detectron2 INFO: Full config saved to ./output/config.yaml +[09/13 14:54:58] d2.utils.env INFO: Using a generated random seed 58068753 +[09/13 14:54:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:54:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:54:58] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[09/13 14:55:03] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cfg/test_xyb.yml b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cfg/test_xyb.yml new file mode 100755 index 0000000000000000000000000000000000000000..632d0032b9ab626afc8ab6d1fcd9a7d286b9324c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cfg/test_xyb.yml @@ -0,0 +1,28 @@ +MODEL: + NAME: VL + + ENCODER: 'hfl/chinese-roberta-wwm-ext' + TEXT_FEATURE_DIM: 768 + TEXT_TRANSFORMER_HEAD: 4 + TEXT_TRANSFORMER_LAYER: 4 + MAX_TEXT_LEN: 80 + + CNN: 'tf_efficientnet_b5_ns' + IMG_SIZE: 456 + IMG_FEATURE_DIM: 2048 + IMG_TRANSFORMER_HEAD: 4 + IMG_TRANSFORMER_LAYER: 4 + MAX_IMG_LEN: 37 + BOX_GRID: 6 + + TOPK: 1 + QUEUE_SIZE: 9600 + MOMENTUM: 0.99 + TEMPERATURE: 0.07 + GRID_SIZE: 4 + IS_EXTRACT: True + +DATASET: + NAME: 'XYBDataset_all' #['AICDataset', 'VLDataset', 'superDataset', 'AICDataset_boxes'] + JSONPATH: '../data/jsonls/example.jsonl' + WORKERS: 8 \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_text_feat.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_text_feat.py new file mode 100755 index 0000000000000000000000000000000000000000..5dcb30ee794a2f9fd50b3d56d21f593f580907f6 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_text_feat.py @@ -0,0 +1,115 @@ +# -*- encoding: utf-8 -*- +''' +@File : text_feat_extractor.py +@Time : 2021/08/26 10:46:15 +@Author : Chuhao Jin +@Email : jinchuhao@ruc.edu.cn +''' + +# here put the import lib + +import os +import sys +import pickle +import argparse + +base_dir = os.path.abspath(os.path.dirname(__file__)) +sys.path.append(base_dir) +import torch +import torch.nn as nn +import torchvision.transforms as transforms +import numpy as np +from transformers import AutoTokenizer + +from utils import getLanMask +from utils.config import cfg_from_yaml_file, cfg +from models.vl_model import * +from tqdm import tqdm +import pdb +import json + + +class TextModel(nn.Module): + def __init__(self, model_cfg): + super(TextModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['textencoder'] = TextLearnableEncoder(model_cfg) + + def forward(self, texts, maskTexts): + textFea = self.learnable['textencoder'](texts, maskTexts) # + textFea = F.normalize(textFea, p=2, dim=-1) + return textFea + + +class TextFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id=0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.cfg.MODEL.ENCODER = os.path.join(base_dir, self.cfg.MODEL.ENCODER) + self.text_model = TextModel(model_cfg=self.cfg.MODEL) + + self.text_model = self.text_model.cuda(self.gpu_id) + model_component = torch.load(model_weights, map_location=torch.device('cuda:{}'.format(self.gpu_id))) + text_model_component = {} + for key in model_component["learnable"].keys(): + if "textencoder." in key: + text_model_component[key] = model_component["learnable"][key] + self.text_model.learnable.load_state_dict(text_model_component) + self.text_model.eval() + + self.text_transform = AutoTokenizer.from_pretrained('./hfl/chinese-bert-wwm-ext') + + def extract(self, text_input): + if text_input is None: + return None + else: + text_info = self.text_transform(text_input, padding='max_length', truncation=True, + max_length=self.cfg.MODEL.MAX_TEXT_LEN, return_tensors='pt') + text = text_info.input_ids.reshape(-1) + text_len = torch.sum(text_info.attention_mask) + with torch.no_grad(): + texts = text.unsqueeze(0) + text_lens = text_len.unsqueeze(0) + textMask = getLanMask(text_lens, cfg.MODEL.MAX_TEXT_LEN) + textMask = textMask.cuda(self.gpu_id) + texts = texts.cuda(self.gpu_id) + text_lens = text_lens.cuda(self.gpu_id) + text_fea = self.text_model(texts, textMask) + text_fea = text_fea.cpu().numpy() + return text_fea + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--txt_path', type=str, default=None) + parser.add_argument('--feat_save_dir', type=str, default=None) + parser.add_argument('--cfg_file', type=str, default='cfg/test_xyb.yml') + parser.add_argument('--brivl_checkpoint', type=str, + default='/innovation_cfs/mmatch/infguo/weights/BriVL-1.0-5500w.pth') + args = parser.parse_args() + + cfg_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), args.cfg_file) + model_weights = args.brivl_checkpoint + vfe = TextFeatureExtractor(cfg_file, model_weights) + + save_dir = args.feat_save_dir + if not os.path.exists(args.feat_save_dir): + os.makedirs(args.feat_save_dir) + + for i in os.listdir(args.txt_path): + clip_data = json.load(open(os.path.join(args.txt_path, i)), encoding='UTF-8') + for clip in clip_data["clips"]: + clip["multi_factor"] = {"semantics": None} + if "original_text" in clip and clip["original_text"] and len(clip["original_text"]) > 0: + text = clip["original_text"] + fea = vfe.extract(text) + fea = fea.squeeze(axis=0).tolist() + clip["multi_factor"]["semantics"] = fea + with open(os.path.join(args.feat_save_dir, i), "w", encoding="utf-8") as fp: + json.dump(clip_data, fp, ensure_ascii=False, indent=4) + + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_video_feat.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_video_feat.py new file mode 100755 index 0000000000000000000000000000000000000000..38e3805521a514acd9c2c6dad9bd1bcee83b5144 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/cut_video_feat.py @@ -0,0 +1,255 @@ +# -*- encoding: utf-8 -*- +# here put the import lib + +import os +import sys +import argparse +import torch +import torch.nn as nn +import torchvision.transforms as transforms +import numpy as np +from PIL import Image +import glob +from tqdm import tqdm +import pickle +import json +import cv2 +import parser +import pandas as pd +import random +import pdb +from torchvision.ops import nms +import traceback +from moviepy.editor import VideoFileClip +import hashlib + +from bbox_extractor.bbox_extractor import BboxExtractor +from img_feat_extractor import generate_folder_csv +from utils import getLanMask +from utils.config import cfg_from_yaml_file, cfg +from models.vl_model import * + + +class ImgModel(nn.Module): + def __init__(self, model_cfg): + super(ImgModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['imgencoder'] = ImgLearnableEncoder(model_cfg) + + def forward(self, imgFea, maskImages, image_boxs): + imgFea = self.learnable['imgencoder'](imgFea, maskImages, image_boxs) # + imgFea = F.normalize(imgFea, p=2, dim=-1) + return imgFea + + +class ImgFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id=0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.img_model = ImgModel(model_cfg=self.cfg.MODEL) + + self.img_model = self.img_model.cuda(self.gpu_id) + model_component = torch.load(model_weights, map_location=torch.device('cuda:{}'.format(self.gpu_id))) + img_model_component = {} + for key in model_component["learnable"].keys(): + if "imgencoder." in key: + img_model_component[key] = model_component["learnable"][key] + self.img_model.learnable.load_state_dict(img_model_component) + self.img_model.eval() + self.visual_transform = self.visual_transforms_box(self.cfg.MODEL.IMG_SIZE) + + def visual_transforms_box(self, new_size=456): + mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + + return transforms.Compose([ + transforms.ToTensor(), + transforms.Resize((new_size, new_size)), + normalize]) + + def extract(self, img_path, bboxes): + if type(img_path)==str: + image = Image.open(img_path).convert('RGB') + else: + image = Image.fromarray(img_path) + if image is None: + return None + else: + width, height = image.size + new_size = self.cfg.MODEL.IMG_SIZE + img_box_s = [] + for box_i in bboxes[:self.cfg.MODEL.MAX_IMG_LEN - 1]: # [x1, y1, x2, y2] + x1, y1, x2, y2 = box_i[0] * (new_size / width), box_i[1] * (new_size / height), box_i[2] * ( + new_size / width), box_i[3] * (new_size / height) + img_box_s.append(torch.from_numpy(np.array([x1, y1, x2, y2]).astype(np.float32))) + img_box_s.append(torch.from_numpy(np.array([0, 0, new_size, new_size]).astype(np.float32))) + + image_boxs = torch.stack(img_box_s, 0) # <36, 4> + image = self.visual_transform(image) + img_len = torch.full((1,), self.cfg.MODEL.MAX_IMG_LEN, dtype=torch.long) + + with torch.no_grad(): + imgs = image.unsqueeze(0) # + img_lens = img_len.unsqueeze(0).view(-1) + image_boxs = image_boxs.unsqueeze(0) # + + # get image mask + imgMask = getLanMask(img_lens, cfg.MODEL.MAX_IMG_LEN) + imgMask = imgMask.cuda(self.gpu_id) + + imgs = imgs.cuda(self.gpu_id) + image_boxs = image_boxs.cuda(self.gpu_id) # + img_fea = self.img_model(imgs, imgMask, image_boxs) + img_fea = img_fea.cpu().numpy() + return img_fea + +def main(video_path, save_path, map_path, vf_extractor, bbx_extr): + + video_name = '.'.join(video_path.split('/')[-1].split('.')[:-1]) + if not os.path.exists(save_path): + os.makedirs(save_path) + # video_hash_code = (os.popen('md5sum {}'.format(video_path))).readlines()[0].split(' ')[0] + with open(video_path, 'rb') as fd: + data = fd.read() + video_hash_code = hashlib.md5(data).hexdigest() + save_path = os.path.join(save_path, '{}_{}.json'.format(video_name, video_hash_code[:8])) + if os.path.exists(save_path) and not args.overwrite: + print('exists ' + save_path) + pass + else: + map_path = os.path.join(map_path, '{}_{}.json'.format(video_name, video_hash_code[:8])) + if not os.path.exists(map_path): + print('map not exist: ', map_path) + return + + video_map = json.load(open(map_path), encoding='UTF-8') + assert video_hash_code == video_map["video_file_hash_code"] + + fps = 1 + max_frame_num = 5 + select_frame_idx = [] + select_frame_clip = [] + for i in range(len(video_map["clips"])): + clip = video_map["clips"][i] + if clip["cliptype"] == "transition": + continue + select_frame_num = int(min(np.ceil(clip["duration"] * fps), max_frame_num)) + clip_total_frame_num = clip["frame_end"] - clip["frame_start"] + frame_duration = clip_total_frame_num // (select_frame_num + 1) + for j in range(select_frame_num): + select_frame_idx.append(clip["frame_start"] + (j + 1) * frame_duration) + select_frame_clip.append(i) + + print(len(select_frame_idx), len(set(select_frame_idx))) + + # Capture video + video = VideoFileClip(video_path) + video = video.crop(*video_map["content_box"]) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + width, height = video.size + print('fps, frame_count, width, height:', fps, total_frames, width, height) + + cnt_frame, step = 0, 0 + for frame in video.iter_frames(fps=video_map["sample_fps"]): + if step == len(select_frame_idx): + break + if cnt_frame == select_frame_idx[step]: + bboxes = bbx_extr.extract_bboxes(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)) + bboxes = bboxes.tolist() + fea = vf_extractor.extract(frame, bboxes) + fea = fea.squeeze(axis=0).tolist() + if "feat" in video_map["clips"][select_frame_clip[step]]: + video_map["clips"][select_frame_clip[step]]["feat"].append(fea) + else: + video_map["clips"][select_frame_clip[step]]["feat"] = [fea] + + step += 1 + cnt_frame += 1 + + # while ret and step < len(select_frame_idx): + # if cnt_frame == select_frame_idx[step]: + # _, frame = video.retrieve() + # bboxes = bbx_extr.extract_bboxes(frame) + # bboxes = bboxes.tolist() + # frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) + # fea = vf_extractor.extract(frame, bboxes) + # fea = fea.squeeze(axis=0).tolist() + # # save_path = os.path.join(args.feat_save_dir, video_name) + # # if not os.path.exists(save_path): + # # os.makedirs(save_path) + # # np.save(os.path.join(save_path, '{:0>8d}.npy'.format(cnt_frame)), fea) + # if "feat" in video_map["clips"][select_frame_clip[step]]: + # video_map["clips"][select_frame_clip[step]]["feat"].append(fea) + # else: + # video_map["clips"][select_frame_clip[step]]["feat"] = [fea] + # + # step += 1 + # print(cnt_frame) + # + # cnt_frame += 1 + # ret = video.grab() + # video.release() + + for clip in video_map["clips"]: + clip["multi_factor"] = {"semantics": None} + if "feat" in clip: + clip["multi_factor"]["semantics"] = np.mean(np.array(clip["feat"]), axis=0).tolist() + + + with open(save_path, "w", encoding="utf-8") as fp: + json.dump(video_map, fp, ensure_ascii=False, indent=4) + + + +if __name__ == '__main__': + # python img_feat_extractor.py --frames_dir ./frames --vid_dir /data_share5/douyin/video --vid_csv_path ./vids.csv --feat_save_dir feats + parser = argparse.ArgumentParser() + parser.add_argument('-src_path', type=str, default='/innovation_cfs/entertainment/VideoMashup/video') + parser.add_argument('-dst_path', type=str, + default='/innovation_cfs/entertainment/VideoMashup/video_map/transnetv2_duration_frameidx_moviepy_feat') + parser.add_argument('-map_path', type=str, + default='/innovation_cfs/entertainment/VideoMashup/video_map/transnetv2_duration_frameidx_moviepy') + # parser.add_argument('--frames_dir', type=str, default=None) + # parser.add_argument('--vid_csv_path', type=str, default=None) + parser.add_argument('--feat_save_dir', type=str, default=None) + parser.add_argument('--cfg_file', type=str, default='cfg/test_xyb.yml') + parser.add_argument('--brivl_checkpoint', type=str, + default='/innovation_cfs/mmatch/infguo/weights/BriVL-1.0-5500w.pth') + parser.add_argument('--bbox_extractor_cfg', type=str, + default='bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml') + parser.add_argument('-overwrite', default=False, action="store_true") # whether overwrite the existing results + + args = parser.parse_args() + abs_path = os.path.dirname(os.path.abspath(__file__)) + cfg_file = os.path.join(abs_path, args.cfg_file) + model_weights = args.brivl_checkpoint + + + vf_extractor = ImgFeatureExtractor(cfg_file, model_weights) + bbx_extr = BboxExtractor(os.path.join(abs_path, args.bbox_extractor_cfg)) + + if os.path.isdir(args.src_path): + for root, _, file_list in os.walk(args.src_path): + file_list.sort() + if '周杰伦mv' in root: + continue + for file in file_list: + print('processing: ', file) + try: + video_path = os.path.join(root, file) + save_path = os.path.join(args.dst_path, root[len(args.src_path) + 1:]) + map_path = os.path.join(args.map_path, root[len(args.src_path) + 1:]) + main(video_path, save_path, map_path, vf_extractor, bbx_extr) + except Exception as e: + traceback.print_exc() + else: + main(args.src_path, args.dst_path, args.map_path, vf_extractor, bbx_extr) + + + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/.md b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/.md new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/test.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/test.py new file mode 100755 index 0000000000000000000000000000000000000000..ff45580333f6607390be28e66dcb0d7615b03d17 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/test.py @@ -0,0 +1,3 @@ +img,songids,scores +6904099770978045195,"332017413, 275610217, 311357445, 105559257, 324505150, 316899937, 307064167, 307904344, 285270326, 335050683, 323171760, 221633081, 285643301, 277967501, 277747013, 288275478, 325932294, 320649384, 263273008, 7023750, 104119488, 311216558, 330011818, 218784668, 266893883, 305351943, 310625094, 318039884, 318039890, 213784149, 310338761, 277591257, 280069866, 315135047, 290066568, 274398055, 307565994, 331069370, 276528866, 318383433, 314909126, 102706334, 5094178, 312117452, 313287585, 291480701, 333291382, 318191773, 275430269, 330979090, 303802288, 303460252, 287396027, 278575032, 323190923, 278470685, 303209103, 277351778, 277347187, 4829312, 274128368, 271916142, 235213591, 328138383, 5546509, 104789548, 323010500, 324230201, 322984175, 105530214, 315037094, 241222460, 255803009, 325148466, 331238341, 321349867, 318827000, 311215192, 318018065, 271741126, 322168312, 332522353, 213910991, 299379515, 310071335, 235146814, 248459225, 330132606, 328996709, 328073648, 212916159, 278991786, 277765528, 8158135, 275056446, 317956938, 7023869, 798372, 321165882, 317018930","0.59024, 0.5606752, 0.55202097, 0.5519614, 0.5508392, 0.54952896, 0.5432125, 0.5405717, 0.5400821, 0.53970855, 0.5389804, 0.53358495, 0.53289056, 0.5326614, 0.52844924, 0.52795327, 0.5273093, 0.52654946, 0.5262934, 0.52549905, 0.52549905, 0.5248249, 0.52472824, 0.5237916, 0.52097666, 0.5201274, 0.5201274, 0.5195188, 0.5195188, 0.51946235, 0.5133663, 0.5132791, 0.5131125, 0.51284444, 0.5123608, 0.51203984, 0.51172227, 0.50921184, 0.5074993, 0.5019861, 0.5014073, 0.49859005, 0.4981646, 0.4975529, 0.49685103, 0.49678925, 0.4967156, 0.4933045, 0.49193192, 0.49144837, 0.4910312, 0.49018678, 0.4898551, 0.489564, 0.4879943, 0.48757687, 0.48742604, 0.48688358, 0.4856954, 0.48433322, 0.4840526, 0.48372522, 0.48312572, 0.48261842, 0.48238167, 0.4823161, 0.48194426, 0.48183432, 0.48139927, 0.48097348, 0.480947, 0.48085177, 0.48070115, 0.48011747, 0.4800818, 0.47980714, 0.479738, 0.4793285, 0.4791447, 0.47914118, 0.47878522, 0.47874293, 0.47851008, 0.47850326, 0.47846332, 0.47846332, 0.47827724, 0.47792554, 0.47782537, 0.47644138, 0.47635078, 0.47596315, 0.47576177, 0.475671, 0.4750232, 0.47490555, 0.47475383, 0.47469568, 0.47464174, 0.47444785" +6987220379404094720,"318261502, 233703730, 105411845, 240297753, 303396208, 331620278, 324309413, 301521447, 297718331, 286008471, 282608644, 213437019, 301785568, 236112325, 276992803, 318831280, 304486501, 277693269, 241527490, 292666221, 267984375, 283646545, 298830568, 102059052, 296441568, 248453785, 272280322, 327387535, 253707382, 273834406, 296559491, 327477276, 231442918, 280844623, 323323050, 323323181, 315830629, 322360007, 308242893, 324797997, 312628765, 220404222, 279008983, 276196066, 329321077, 330667951, 108753430, 332017413, 318303728, 301247657, 275369084, 305029334, 246831769, 300099253, 328456149, 244636429, 314080530, 305027723, 332034290, 321254664, 287670890, 331067377, 254970403, 250977046, 335597081, 328140349, 304215835, 293823723, 323837641, 329869832, 325371384, 9081399, 101092550, 278877272, 273981108, 307288119, 213781828, 103974294, 330183167, 327427197, 312380363, 296971842, 227977759, 109622807, 102444678, 7050970, 108753950, 331127164, 323065862, 212916159, 239140453, 239899449, 326316807, 274128368, 247258934, 303450093, 303450090, 274489555, 291030977, 273833353","0.40107077, 0.356166, 0.35560432, 0.3468786, 0.3396401, 0.3298031, 0.32824078, 0.31984243, 0.31873178, 0.3186271, 0.31199858, 0.3093462, 0.30703223, 0.30685034, 0.30358642, 0.30273697, 0.30008712, 0.2996056, 0.29580837, 0.29392487, 0.29118562, 0.28875116, 0.28655392, 0.28641468, 0.28502044, 0.28233862, 0.2783531, 0.2777805, 0.27712524, 0.27590588, 0.275563, 0.27395236, 0.27249968, 0.27156296, 0.27111584, 0.27111584, 0.27111584, 0.27067968, 0.27066094, 0.26929003, 0.2669757, 0.2664488, 0.26616544, 0.26616544, 0.26550198, 0.2650067, 0.2638799, 0.26361507, 0.26356968, 0.26302677, 0.26104087, 0.2602063, 0.25833023, 0.25690156, 0.2561007, 0.2556904, 0.25512356, 0.25455573, 0.25141332, 0.25135303, 0.2512689, 0.2512216, 0.25000978, 0.25000978, 0.24982464, 0.24967606, 0.2496449, 0.24898383, 0.24833846, 0.24781804, 0.24752569, 0.24683149, 0.24683149, 0.24662471, 0.2464665, 0.24616489, 0.2459665, 0.24579251, 0.24551137, 0.24511166, 0.24511166, 0.24343331, 0.24295157, 0.24293843, 0.24261406, 0.24261406, 0.24207427, 0.24102451, 0.24076271, 0.2406941, 0.24059144, 0.24059144, 0.23966606, 0.23902386, 0.23877335, 0.23800166, 0.23800166, 0.23702033, 0.2366779, 0.23618999" diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/video2music_retrieval.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/video2music_retrieval.py new file mode 100755 index 0000000000000000000000000000000000000000..387d63917d10040a637961f9aa7c2a0abe46182f --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/evaluation/video2music_retrieval.py @@ -0,0 +1,135 @@ +import os +import numpy as np +import random +from tqdm import tqdm +import argparse +import torch +import sys +import glob +import csv +import torch.utils.data as data +import pandas as pd +import re +import pdb +sys.path.append(os.path.abspath(os.path.dirname(os.path.realpath(__file__))+'/'+'..')) + +parser = argparse.ArgumentParser() +parser.add_argument('--vid_csv_path', type=str, default=None) +parser.add_argument('--image_dir', type=str, default=None) +parser.add_argument('--text_dir', type=str, default=None) +parser.add_argument('--lyric_txt_path', type=str, default=None) +parser.add_argument('--save_csv', type=str, default=None) +parser.add_argument('--gpu', type=str, default='3') +args = parser.parse_args() +os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu + + +# python video2img_retrieval.py --vid_csv_path ../vids.csv --image_dir ../feats --text_dir ../../BriVL-git/BriVL_code_inference/feat/text_vivo_5w_songids/ --lyric_txt_path /data/home/sxhong/tools/get_lyric/data/vivo_top5w_songid_lyrics.lyric --save_csv test.csv + + +def get_ImgFeat(img_feats): + # 获取imgs_feat + img_dict = {} + for i, np_img_path in enumerate(img_feats): + img_dict[i] = np_img_path + if i == 0: + np_img = np.expand_dims(np.load(np_img_path).astype(np.float64), axis=0) + else: + np_img = np.concatenate((np_img, np.expand_dims(np.load(np_img_path).astype(np.float64), axis=0)), axis=0) + img = torch.from_numpy(np_img).cuda() + return img_dict, img + + +class Text_Dataset(data.Dataset): + def __init__(self, text_dir): + self.text_feats = glob.glob(os.path.join(text_dir, '*.npy')) + + def __len__(self): + return len(self.text_feats) + + def __getitem__(self, index): + text_path = self.text_feats[index] + songid = text_path.split('/')[-1].split('.')[0] + text_feat = np.load(text_path) + return songid, text_feat + +def get_TextFeat(text_dir): + # pdb.set_trace() + # 获取texts_feat + dataset = Text_Dataset(text_dir) + dataloader = data.DataLoader(dataset, batch_size=5000, shuffle=False) + all_songids = [] + for i, (songid_, text_feats) in enumerate(dataloader): + all_songids.extend(list(songid_)) + if i == 0: + text = text_feats + else: + text = torch.cat((text, text_feats), 0) + text = text.squeeze(dim=1) + text = text.cuda() + return all_songids, text + + +def get_lyric(lyric_txt_path): + # songid对应的歌词 + text_dict = {} + for line in open(lyric_txt_path): + try: + songid, text_query = line.split(',')[0], line.split('"')[1] + text_dict[songid] = text_query + except: + pass + return text_dict + + +vids = pd.read_csv(args.vid_csv_path, dtype=str)['vid'].to_list() +all_songids, text = get_TextFeat(args.text_dir) +text_dict = get_lyric(args.lyric_txt_path) +vid2songid = {} + +for vid in vids: + img_feat_paths = glob.glob(os.path.join(args.image_dir, str(vid)+'_'+'*.npy')) + img_dict, img = get_ImgFeat(img_feat_paths) + N_img = img.shape[0] + N_text = text.shape[0] + scores = torch.zeros((N_img, N_text), dtype=torch.float32).cuda() + + print('Pair-to-pair: calculating scores') + for i in tqdm(range(N_img)): # row: image col: text + scores[i, :] = torch.sum(img[i] * text, -1) + + songid2score = {} + songids = [] + songids2scores = [] + for i, score in enumerate(scores): + indices = torch.argsort(score, descending=True) + songids = [] + for idx in indices: + if len(songids) <= 80: + idx = int(idx.cpu().numpy()) + query_text = text_dict[all_songids[idx]] + query_text = query_text.split(',') + query_text = (query_text[len(query_text) // 2]).replace(' ','').replace('*','') + for exist_songid in songids: + key_text = (text_dict[exist_songid]).replace(' ','').replace('*','') + if re.findall(query_text, key_text): + if float(songid2score[exist_songid]) < float(score[idx].cpu().numpy()): + songid2score.pop(exist_songid) + songid2score[all_songids[idx]] = str(score[idx].cpu().numpy()) + break + + songid2score[all_songids[idx]] = str(score[idx].cpu().numpy()) + else: + break + sorted_songid2score = sorted(songid2score.items(), key=lambda x:float(x[1]), reverse=True) + select_songids = ', '.join([songid for songid, score in sorted_songid2score[:100]]) + correspond_scores = ', '.join([score for songid, score in sorted_songid2score[:100]]) + vid2songid[vid] = (select_songids, correspond_scores) + +data = [] +for vid, values in vid2songid.items(): + songids, scores = values + data.append([vid, songids, scores]) + +df = pd.DataFrame(data, columns=['img', 'songids', 'scores']) +df.to_csv(args.save_csv, index=False) \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/img_feat_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/img_feat_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..073f41384ad11b544f05bb8cacb87867b7dff960 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/img_feat_extractor.py @@ -0,0 +1,146 @@ +# -*- encoding: utf-8 -*- +# here put the import lib + +import os +import sys +import argparse +import torch +import torch.nn as nn +import torchvision.transforms as transforms +import numpy as np +from PIL import Image +from .utils import getLanMask +from .utils.config import cfg_from_yaml_file, cfg +from .models.vl_model import * +import glob +from tqdm import tqdm +import pickle +import json +import cv2 +from torchvision.ops import nms +from .bbox_extractor.bbox_extractor import BboxExtractor +import parser +import pandas as pd +import random +import pdb + +class ImgModel(nn.Module): + def __init__(self, model_cfg): + super(ImgModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['imgencoder'] = ImgLearnableEncoder(model_cfg) + + def forward(self, imgFea, maskImages, image_boxs): + imgFea = self.learnable['imgencoder'](imgFea, maskImages, image_boxs) # + imgFea = F.normalize(imgFea, p=2, dim=-1) + return imgFea + +class ImgFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id = 0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.img_model = ImgModel(model_cfg=self.cfg.MODEL) + + self.img_model = self.img_model.cuda(self.gpu_id) + model_component = torch.load(model_weights, map_location=torch.device('cuda:{}'.format(self.gpu_id))) + img_model_component = {} + for key in model_component["learnable"].keys(): + if "imgencoder." in key: + img_model_component[key] = model_component["learnable"][key] + self.img_model.learnable.load_state_dict(img_model_component) + self.img_model.eval() + self.visual_transform = self.visual_transforms_box(self.cfg.MODEL.IMG_SIZE) + + def visual_transforms_box(self, new_size = 456): + mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + + return transforms.Compose([ + transforms.ToTensor(), + transforms.Resize((new_size, new_size)), + normalize]) + + def extract(self, img_path, bboxes): + image = Image.open(img_path).convert('RGB') + if image is None: + return None + else: + width, height = image.size + new_size = self.cfg.MODEL.IMG_SIZE + img_box_s = [] + for box_i in bboxes[:self.cfg.MODEL.MAX_IMG_LEN-1]: # [x1, y1, x2, y2] + x1, y1, x2, y2 = box_i[0] * (new_size/width), box_i[1] * (new_size/height), box_i[2] * (new_size/width), box_i[3] * (new_size/height) + img_box_s.append(torch.from_numpy(np.array([x1, y1, x2, y2]).astype(np.float32))) + img_box_s.append(torch.from_numpy(np.array([0, 0, new_size, new_size]).astype(np.float32))) + + image_boxs = torch.stack(img_box_s, 0) # <36, 4> + image = self.visual_transform(image) + img_len = torch.full((1,), self.cfg.MODEL.MAX_IMG_LEN, dtype=torch.long) + + with torch.no_grad(): + imgs = image.unsqueeze(0) # + img_lens = img_len.unsqueeze(0).view(-1) + image_boxs = image_boxs.unsqueeze(0) # + + # get image mask + imgMask = getLanMask(img_lens, cfg.MODEL.MAX_IMG_LEN) + imgMask = imgMask.cuda(self.gpu_id) + + imgs = imgs.cuda(self.gpu_id) + image_boxs = image_boxs.cuda(self.gpu_id) # + img_fea = self.img_model(imgs, imgMask, image_boxs) + img_fea = img_fea.cpu().numpy() + return img_fea + + +def generate_folder_csv(dir, save_path): + vid_dir = [] + for fn in os.listdir(dir): + if os.path.isdir(os.path.join(dir, fn)): vid_dir.append(fn) + vid_dir_pd = pd.DataFrame(vid_dir) + # pdb.set_trace() + vid_dir_pd.columns = ['vid'] + vid_dir_pd.to_csv(save_path) + + +if __name__ == '__main__': + # python img_feat_extractor.py --photoalbum_dir ./frames --csv_path ./vids.csv --feat_save_dir feats + parser = argparse.ArgumentParser() + parser.add_argument('--photoalbum_dir', type=str, default=None) + parser.add_argument('--photoalbum_csv_path', type=str, default=None) + + parser.add_argument('--feat_save_dir', type=str, default=None) + parser.add_argument('--cfg_file', type=str, default='cfg/test_xyb.yml') + parser.add_argument('--brivl_checkpoint', type=str, default='/data_share7/sxhong/project/BriVL/weights/BriVL-1.0-5500w.pth') + parser.add_argument('--bbox_extractor_cfg', type=str, default='bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml') + + args = parser.parse_args() + if not os.path.exists(args.feat_save_dir): + os.makedirs(args.feat_save_dir) + cfg_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), args.cfg_file) + model_weights = args.brivl_checkpoint + + vf_extractor = ImgFeatureExtractor(cfg_file, model_weights) + abs_path = os.path.dirname(os.path.abspath(__file__)) + bbx_extr = BboxExtractor(os.path.join(abs_path, args.bbox_extractor_cfg)) + generate_folder_csv(args.photoalbum_dir, args.photoalbum_csv_path) + vids = pd.read_csv(args.photoalbum_csv_path, dtype=str)['vid'].to_list() + # pdb.set_trace() + for vid in vids: + frame_path = os.path.join(args.photoalbum_dir, vid) + # pdb.set_trace() + frame_name_list = glob.glob(os.path.join(frame_path, '*.jpg')) + frame_name_list2 = glob.glob(os.path.join(frame_path, '*.jpeg')) + frame_name_list.extend(frame_name_list2) + for frame_path in frame_name_list: + img_save_path = os.path.join(args.feat_save_dir, frame_path.split('/')[-2]+'_'+frame_path.split('/')[-1].replace('jpg', 'npy').replace('jpeg', 'npy')) + bboxes = bbx_extr.extract_bboxes(frame_path) + bboxes = bboxes.tolist() + fea = vf_extractor.extract(frame_path, bboxes) + fea = fea.squeeze(axis=0) + np.save(img_save_path, fea) + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..f1ea319eee4bf75ceabdd09a22769c90f4e38a36 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/__init__.py @@ -0,0 +1,14 @@ +from .vl_model import VL_model + +import torch + +__all__ = { + 'VL': VL_model +} + + +def build_network(model_cfg=None): + model = __all__[model_cfg.NAME]( + model_cfg=model_cfg + ) + return model diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/bert.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/bert.py new file mode 100755 index 0000000000000000000000000000000000000000..66c4be401d3ab3295d3b11767fc778c50ad006d9 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/bert.py @@ -0,0 +1,18 @@ +import torch +import torch.nn as nn +from transformers import AutoModel + + +class Bert(nn.Module): + + def __init__(self, args): + super(Bert, self).__init__() + self.args = args + self.bert = AutoModel.from_pretrained('./hfl/chinese-bert-wwm-ext') +# self.bert = AutoModel.from_pretrained(args.ENCODER) + #self.bert = AutoModel.from_pretrained('bert-base-chinese') + + def forward(self, x): + # y = torch.ones((int(self.args.batch_size/4), self.args.max_textLen, self.args.textFea_dim),device=x.device) + y = self.bert(x, return_dict=True).last_hidden_state + return y diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/fakeTransformer.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/fakeTransformer.py new file mode 100755 index 0000000000000000000000000000000000000000..abfb2c591089ac4801d37a4729b8755738fc8360 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/fakeTransformer.py @@ -0,0 +1,19 @@ +import torch +import torch.nn as nn + + +class FakeTransformer(nn.Module): + + def __init__(self, input_dim, hidden_dim, output_dim): + super(FakeTransformer, self).__init__() + + self.fc1 = nn.Linear(input_dim, hidden_dim) + self.relu = nn.ReLU() + self.fc2 = nn.Linear(hidden_dim, output_dim) + + def forward(self, x): + out = self.fc1(x) + out = self.relu(out) + out = self.fc2(out) + + return out diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/vl_model.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/vl_model.py new file mode 100755 index 0000000000000000000000000000000000000000..c00d66347bee250934739db8e2acbfc043b596b8 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/models/vl_model.py @@ -0,0 +1,441 @@ +import torch +import torch.nn as nn +from .fakeTransformer import FakeTransformer +from .bert import Bert +from ..utils import pairLoss, alignmentLoss, attAlignmentLoss, AlignTripLoss, SimpTripLoss, NCELoss +import torch.nn.functional as F +import timm +import numpy as np +import sys + +class ImgLearnableEncoder(nn.Module): + def __init__(self, model_cfg): + + super(ImgLearnableEncoder, self).__init__() + + self.backbone = timm.create_model(model_cfg.CNN, pretrained=True) + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['imgFC'] = FakeTransformer(model_cfg.IMG_FEATURE_DIM, model_cfg.IMG_FEATURE_DIM, model_cfg.IMG_FEATURE_DIM) + img_encoder_layer = nn.TransformerEncoderLayer(d_model=model_cfg.IMG_FEATURE_DIM, nhead=model_cfg.IMG_TRANSFORMER_HEAD) + self.learnable['imgAtt'] = nn.TransformerEncoder(img_encoder_layer, num_layers=model_cfg.IMG_TRANSFORMER_LAYER) + + self.learnable['max_pool'] = nn.Sequential( + nn.Conv2d(model_cfg.IMG_FEATURE_DIM, model_cfg.IMG_FEATURE_DIM, kernel_size=1), + nn.AvgPool2d(model_cfg.GRID_SIZE, stride=1) + ) + + self.init_param() + + def init_param(self): + + for name, param in self.backbone.named_parameters(): + # print('@@@@@@@@@@@@@@@@@@@@@@@') + + condition = 'blocks.6' not in name and 'blocks.5' not in name and 'blocks.4' not in name and 'blocks.3' not in name + + if condition: + param.requires_grad = False + else: +# print(name + ' need grads') + param.requires_grad = True + sys.stdout.flush() + + + + def roi_grid_pool(self, spatial_features_2d, rois): + """ + Args: + rois: (B, num_rois, 4) + spatial_features_2d: (B, C, H, W) + Returns: + pooled_features : (B, num_rois, C) + + """ + batch_size = spatial_features_2d.size(0) + rois = rois.detach() + height, width = spatial_features_2d.size(2), spatial_features_2d.size(3) # 特征图的长宽 + + #print(spatial_features_2d.size()) + down_sample_ratio = self.model_cfg.IMG_SIZE / height + + pooled_features_list = [] + torch.backends.cudnn.enabled = False + for b_id in range(batch_size): + # todo 这里有一个坐标系的转换需要做 + # Map global boxes coordinates to feature map coordinates + x1 = rois[b_id, :, 0] / down_sample_ratio + y1 = rois[b_id, :, 1] / down_sample_ratio + x2 = rois[b_id, :, 2] / down_sample_ratio + y2 = rois[b_id, :, 3] / down_sample_ratio + #print(x1, y1, x2, y2) + + angle = torch.zeros((1), device=spatial_features_2d.device) ########## + + cosa = torch.cos(angle) + sina = torch.sin(angle) + + theta = torch.stack(( + (x2 - x1) / (width - 1) * cosa, (x2 - x1) / (width - 1) * (-sina), (x1 + x2 - width + 1) / (width - 1), + (y2 - y1) / (height - 1) * sina, (y2 - y1) / (height - 1) * cosa, (y1 + y2 - height + 1) / (height - 1) + ), dim=1).view(-1, 2, 3).float() + + grid_size = self.model_cfg.GRID_SIZE + grid = nn.functional.affine_grid( + theta, + torch.Size((rois.size(1), spatial_features_2d.size(1), grid_size, grid_size)) + ) + + pooled_features = nn.functional.grid_sample( + spatial_features_2d[b_id].unsqueeze(0).expand(rois.size(1), spatial_features_2d.size(1), height, width), + grid + ) + pooled_features = self.learnable['max_pool'](pooled_features) + pooled_features_list.append(pooled_features.squeeze()) + + torch.backends.cudnn.enabled = True + pooled_features = torch.stack(pooled_features_list, dim=0) + + return pooled_features + + def forward(self, imgFea, maskImages, image_boxs): + + feature_map = self.backbone.forward_features(imgFea) + imgFea = self.roi_grid_pool(feature_map, image_boxs) + + imgFea = F.normalize(imgFea, p=2, dim=-1) + imgFea = self.learnable['imgAtt'](imgFea.transpose(0, 1), src_key_padding_mask=(maskImages == 0)).transpose(0,1) + + tmpMask = torch.where(maskImages == 1, torch.tensor([1.0], device=maskImages.device), + torch.tensor([0.0], device=maskImages.device)) + imgFea = (imgFea * tmpMask.unsqueeze(-1)).sum(dim=1) / tmpMask.sum(dim=1).unsqueeze(-1) # (bs, dim) + + imgFea = self.learnable['imgFC'](imgFea) + return imgFea + + +class TextLearnableEncoder(nn.Module): + def __init__(self, model_cfg): + super(TextLearnableEncoder, self).__init__() + + self.backbone = Bert(model_cfg) + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['textFC'] = FakeTransformer(model_cfg.TEXT_FEATURE_DIM, model_cfg.IMG_FEATURE_DIM, model_cfg.IMG_FEATURE_DIM) + text_encoder_layer = nn.TransformerEncoderLayer(d_model=model_cfg.TEXT_FEATURE_DIM, nhead=model_cfg.TEXT_TRANSFORMER_HEAD) + self.learnable['textAtt'] = nn.TransformerEncoder(text_encoder_layer, num_layers=model_cfg.TEXT_TRANSFORMER_LAYER) + + self.init_param() + + def init_param(self): + #print('!!!!!!!!!!!!!!!!') + for name, param in self.backbone.named_parameters(): + #print(name) + if 'large' not in self.model_cfg.ENCODER: + + if 'layer.11' not in name and 'layer.10' not in name and 'layer.9' not in name and 'layer.8' not in name: + param.requires_grad = False + else: + #print('????????') +# print(name + ' need grads') + param.requires_grad = True + else: + if 'layer.21' not in name and 'layer.22' not in name and 'layer.23' not in name and 'layer.20' not in name: # and 'layer.9' not in name + param.requires_grad = False + else: + #print('????????') +# print(name + ' need grads') + param.requires_grad = True + sys.stdout.flush() + + + def forward(self, textFea, maskTexts): + + textFea = self.backbone(textFea) + + textFea = F.normalize(textFea, p=2, dim=-1) + # print(textFea.shape) # torch.Size([75, 80, 1024]) + # print(maskTexts.shape) + # print(1) + textFea = self.learnable['textAtt'](textFea.transpose(0, 1), src_key_padding_mask=(maskTexts == 0)).transpose(0,1) + # print(textFea.shape) # torch.Size([75, 80, 1024]) + # print(2) + tmpMask = torch.where(maskTexts == 1, torch.tensor([1.0], device=maskTexts.device), + torch.tensor([0.0], device=maskTexts.device)) + textFea = (textFea * tmpMask.unsqueeze(-1)).sum(dim=1) / tmpMask.sum(dim=1).unsqueeze(-1) # (bs, dim) + # print(textFea.shape) # torch.Size([75, 80, 1024]) + # print(3) + textFea = self.learnable['textFC'](textFea) + # print(textFea.shape) # torch.Size([75, 80, 1024]) + # print(4) + return textFea + + + +class VL_model(nn.Module): + + def __init__(self, model_cfg): + super(VL_model, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['imgencoder'] = ImgLearnableEncoder(model_cfg) + self.learnable['imgencoder_mom'] = ImgLearnableEncoder(model_cfg) + self.learnable['textencoder'] = TextLearnableEncoder(model_cfg) + self.learnable['textencoder_mom'] = TextLearnableEncoder(model_cfg) + #self.generator = Generator(model_cfg) + + ############ add new params in .yml config file + self.K = model_cfg.QUEUE_SIZE # 6400 + self.m = model_cfg.MOMENTUM # 0.9 + self.T = model_cfg.TEMPERATURE # 0.07 + self.topk = model_cfg.TOPK # 5 + self.multi_label = False + ############ add new params in .yml config file + + # init the parameter of two models + self.init_param() + # create the img queue + self.register_buffer("img_queue", torch.randn(model_cfg.IMG_FEATURE_DIM, self.K)) + self.img_queue = nn.functional.normalize(self.img_queue, dim=0) + self.register_buffer("img_queue_ptr", torch.zeros(1, dtype=torch.long)) # image queue points + # create the text queue + self.register_buffer("text_queue", torch.randn(model_cfg.IMG_FEATURE_DIM, self.K)) + self.text_queue = nn.functional.normalize(self.text_queue, dim=0) + self.register_buffer("text_queue_ptr", torch.zeros(1, dtype=torch.long)) # text queue points + + + def init_param(self): + + for param_q, param_k in zip(self.learnable['imgencoder'].parameters(), self.learnable['imgencoder_mom'].parameters()): + param_k.data.copy_(param_q.data) # initialize + param_k.requires_grad = False # not update by gradient + + for param_q, param_k in zip(self.learnable['textencoder'].parameters(), self.learnable['textencoder_mom'].parameters()): + param_k.data.copy_(param_q.data) # initialize + param_k.requires_grad = False # not update by gradient + + + @torch.no_grad() + def _momentum_update_key_encoder(self): + """ + Momentum update of the key encoder for image modal + """ + for param_q, param_k in zip(self.learnable['imgencoder'].parameters(), self.learnable['imgencoder_mom'].parameters()): + param_k.data = param_k.data * self.m + param_q.data * (1. - self.m) + for param_q, param_k in zip(self.learnable['textencoder'].parameters(), self.learnable['textencoder_mom'].parameters()): + param_k.data = param_k.data * self.m + param_q.data * (1. - self.m) + + @torch.no_grad() + def _dequeue_and_enqueue(self, keys, option='img'): + # option in + # gather keys before updating queue + keys = concat_all_gather(keys) + + batch_size = keys.shape[0] + + if option == 'img': + ptr = int(self.img_queue_ptr) + assert self.K % batch_size == 0 # for simplicity + + # replace the keys at ptr (dequeue and enqueue) + self.img_queue[:, ptr:ptr + batch_size] = keys.T + ptr = (ptr + batch_size) % self.K # move pointer + + self.img_queue_ptr[0] = ptr + + else: + + ptr = int(self.text_queue_ptr) + assert self.K % batch_size == 0 # for simplicity + + # replace the keys at ptr (dequeue and enqueue) + self.text_queue[:, ptr:ptr + batch_size] = keys.T + ptr = (ptr + batch_size) % self.K # move pointer + + self.text_queue_ptr[0] = ptr + + + @torch.no_grad() + def _batch_shuffle_ddp(self, x, x_mask): + """ + Batch shuffle, for making use of BatchNorm. + *** Only support DistributedDataParallel (DDP) model. *** + """ + # gather from all gpus + batch_size_this = x.shape[0] + x_gather = concat_all_gather(x) + x_mask_gather = concat_all_gather(x_mask) + batch_size_all = x_gather.shape[0] + + num_gpus = batch_size_all // batch_size_this + + # random shuffle index + idx_shuffle = torch.randperm(batch_size_all).cuda() + + # broadcast to all gpus + torch.distributed.broadcast(idx_shuffle, src=0) + + # index for restoring + idx_unshuffle = torch.argsort(idx_shuffle) + + # shuffled index for this gpu + gpu_idx = torch.distributed.get_rank() + idx_this = idx_shuffle.view(num_gpus, -1)[gpu_idx] + + return x_gather[idx_this], x_mask_gather[idx_this], idx_unshuffle + + @torch.no_grad() + def _batch_unshuffle_ddp(self, x, x_mask, idx_unshuffle): + """ + Undo batch shuffle. + *** Only support DistributedDataParallel (DDP) model. *** + """ + # gather from all gpus + batch_size_this = x.shape[0] + x_gather = concat_all_gather(x) + x_mask_gather = concat_all_gather(x_mask) + batch_size_all = x_gather.shape[0] + + num_gpus = batch_size_all // batch_size_this + + # restored index for this gpu + gpu_idx = torch.distributed.get_rank() + idx_this = idx_unshuffle.view(num_gpus, -1)[gpu_idx] + + return x_gather[idx_this], x_mask_gather[idx_this] + + + def forward(self, imgFea, texts, maskImages, maskTexts, text_lens, image_boxs, is_training=True): + + if self.model_cfg.IS_EXTRACT: + return self.extract(imgFea, texts, maskImages, maskTexts, image_boxs) + + batch_size = imgFea.size(0) + + imgFea_q = self.learnable['imgencoder'](imgFea, maskImages, image_boxs) # + imgFea_q = F.normalize(imgFea_q, p=2, dim=-1) + textFea_q = self.learnable['textencoder'](texts, maskTexts) # + textFea_q = F.normalize(textFea_q, p=2, dim=-1) + + # compute key features + with torch.no_grad(): # no gradient to keys + self._momentum_update_key_encoder() # update the key encoder + + # shuffle for making use of BN + imgFea, image_boxs, idx_unshuffle = self._batch_shuffle_ddp(imgFea, image_boxs) + + imgFea_k = self.learnable['imgencoder_mom'](imgFea, maskImages, image_boxs) # + imgFea_k = F.normalize(imgFea_k, p=2, dim=-1) + + # undo shuffle + imgFea_k, image_boxs = self._batch_unshuffle_ddp(imgFea_k, image_boxs, idx_unshuffle) + + # shuffle for making use of BN + texts, maskTexts, idx_unshuffle = self._batch_shuffle_ddp(texts, maskTexts) + + textFea_k = self.learnable['textencoder_mom'](texts, maskTexts) # + textFea_k = F.normalize(textFea_k, p=2, dim=-1) + + # undo shuffle + textFea_k, maskTexts = self._batch_unshuffle_ddp(textFea_k, maskTexts, idx_unshuffle) + + + # compute logits for image -> text + # positive logits: Nx1 + i2t_l_pos = torch.einsum('nc,nc->n', [imgFea_q, textFea_k]).unsqueeze(-1) + # negative logits: NxK + i2t_l_neg = torch.einsum('nc,ck->nk', [imgFea_q, self.text_queue.clone().detach()]) + + # logits: Nx(1+K) + i2t_logits = torch.cat([i2t_l_pos, i2t_l_neg], dim=-1) + i2t_logits /= self.T + + # compute logits for text -> image + # positive logits: Nx1 + t2i_l_pos = torch.einsum('nc,nc->n', [textFea_q, imgFea_k]).unsqueeze(-1) + # negative logits: NxK + t2i_l_neg = torch.einsum('nc,ck->nk', [textFea_q, self.img_queue.clone().detach()]) + + # logits: Nx(1+K) + t2i_logits = torch.cat([t2i_l_pos, t2i_l_neg], dim=-1) + t2i_logits /= self.T + + + ### multi-label + mask = torch.zeros((batch_size, self.K)).bool().cuda() # + + if self.multi_label: + mask_sim_txt = textFea_k.matmul(self.text_queue.clone().detach()) # -> + mask_sim_img = imgFea_k.matmul(self.img_queue.clone().detach()) + + _, topkidx_txt = torch.topk(mask_sim_txt, self.topk, dim=1) # + _, topkidx_img = torch.topk(mask_sim_img, self.topk, dim=1) # + topk_onehot_txt = torch.zeros_like(mask_sim_txt) # + topk_onehot_txt.scatter_(1, topkidx_txt, 1) # one hot vector + topk_onehot_img = torch.zeros_like(mask_sim_img) # + topk_onehot_img.scatter_(1, topkidx_img, 1) # one hot vector + + mask[topk_onehot_txt.bool() & topk_onehot_img.bool()] = True # + + + mask = torch.cat([torch.ones((batch_size, 1), dtype=torch.long, device=mask.device).bool(), + mask], dim=1) # + + ### multi-label + t2i_loss = -1 * F.log_softmax(t2i_logits, dim=1) # + t2i_loss = torch.masked_select(t2i_loss, mask).sum() / batch_size # masked_select return 1-d tensor + i2t_loss = -1 * F.log_softmax(i2t_logits, dim=1) + i2t_loss = torch.masked_select(i2t_loss, mask).sum() / batch_size # masked_select return 1-d tensor + + loss = t2i_loss + i2t_loss + + ## enqueue and dequeue + self._dequeue_and_enqueue(imgFea_k, option='img') + self._dequeue_and_enqueue(textFea_k, option='text') + + # ----------caption------------- + # TODO: update + ''' + if is_training: + caption = None + caption_loss = self.generator(imgFea_q, texts, text_lens, maskTexts, is_training) + else: + caption_loss, caption = self.generator(imgFea_q, texts, text_lens, maskTexts, is_training) + ''' + + return loss#, caption_loss, caption + + + def extract(self, imgFea, texts, maskImages, maskTexts, image_boxs): + + + imgFea = self.learnable['imgencoder'](imgFea, maskImages, image_boxs) # + textFea = self.learnable['textencoder'](texts, maskTexts) # + + imgFea = F.normalize(imgFea, p=2, dim=-1) + textFea = F.normalize(textFea, p=2, dim=-1) + + retrieval_feat_group = {} + + retrieval_feat_group['img_text'] = (imgFea, textFea) + + return retrieval_feat_group + + +# utils +@torch.no_grad() +def concat_all_gather(tensor): + """ + Performs all_gather operation on the provided tensors. + *** Warning ***: torch.distributed.all_gather has no gradient. + """ + tensors_gather = [torch.ones_like(tensor) + for _ in range(torch.distributed.get_world_size())] + torch.distributed.all_gather(tensors_gather, tensor, async_op=False) + + output = torch.cat(tensors_gather, dim=0) + return output \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/config.yaml b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/config.yaml new file mode 100755 index 0000000000000000000000000000000000000000..900a5d16e78977d23916f7379a05855b24bf4dd7 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/config.yaml @@ -0,0 +1,317 @@ +CUDNN_BENCHMARK: false +DATALOADER: + ASPECT_RATIO_GROUPING: true + FILTER_EMPTY_ANNOTATIONS: true + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: [] + PROPOSAL_FILES_TRAIN: [] + TEST: [] + TRAIN: [] +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: false + SIZE: + - 0.9 + - 0.9 + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: + - 600 + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: + - - -90 + - 0 + - 90 + ASPECT_RATIOS: + - - 0.5 + - 1.0 + - 2.0 + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: + - - 4 + - 8 + - 16 + - 32 + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: true + CAFFE: true + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: true + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: '' + OUT_CHANNELS: 256 + KEYPOINT_ON: false + LOAD_PROPOSALS: false + MASK_ON: false + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: true + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: + - 102.9801 + - 115.9465 + - 122.7717 + PIXEL_STD: + - 1.0 + - 1.0 + - 1.0 + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: false + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: + - false + - false + - false + - false + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: + - res4 + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: true + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: + - p3 + - p4 + - p5 + - p6 + - p7 + IOU_LABELS: + - 0 + - -1 + - 1 + IOU_THRESHOLDS: + - 0.4 + - 0.5 + NMS_THRESH_TEST: 0.5 + NORM: '' + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: + - - 10.0 + - 10.0 + - 5.0 + - 5.0 + - - 20.0 + - 20.0 + - 10.0 + - 10.0 + - - 30.0 + - 30.0 + - 15.0 + - 15.0 + IOUS: + - 0.5 + - 0.6 + - 0.7 + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + CLS_AGNOSTIC_BBOX_REG: false + CONV_DIM: 256 + FC_DIM: 1024 + NAME: '' + NORM: '' + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: false + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: + - res4 + IOU_LABELS: + - 0 + - 1 + IOU_THRESHOLDS: + - 0.5 + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: true + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + - 512 + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: true + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: false + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: '' + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: + - 1.0 + - 1.0 + - 1.0 + - 1.0 + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: + - res4 + IOU_LABELS: + - 0 + - -1 + - 1 + IOU_THRESHOLDS: + - 0.3 + - 0.7 + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: + - p2 + - p3 + - p4 + - p5 + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: false + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: false + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: false + REFERENCE_WORLD_SIZE: 0 + STEPS: + - 30000 + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: false + FLIP: true + MAX_SIZE: 4000 + MIN_SIZES: + - 400 + - 500 + - 600 + - 700 + - 800 + - 900 + - 1000 + - 1100 + - 1200 + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: false + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/log.txt b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/log.txt new file mode 100755 index 0000000000000000000000000000000000000000..df425f1e7bd40df08d8c4e14f3cf83a3c782878d --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/output/log.txt @@ -0,0 +1,6304 @@ +[01/06 17:10:23] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:10:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:10:28] detectron2 INFO: Command line arguments: None +[01/06 17:10:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:10:28] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:10:28] d2.utils.env INFO: Using a generated random seed 28631635 +[01/06 17:10:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:30] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:10:55] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:10:56] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:10:56] detectron2 INFO: Command line arguments: None +[01/06 17:10:56] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:10:56] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:10:56] d2.utils.env INFO: Using a generated random seed 56797567 +[01/06 17:10:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:56] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:10:58] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:11:27] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:11:28] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:11:28] detectron2 INFO: Command line arguments: None +[01/06 17:11:28] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:11:28] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:11:28] d2.utils.env INFO: Using a generated random seed 28460660 +[01/06 17:11:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:11:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:11:28] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:11:29] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:12:49] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:12:50] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:12:50] detectron2 INFO: Command line arguments: None +[01/06 17:12:50] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:12:50] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:12:50] d2.utils.env INFO: Using a generated random seed 50657293 +[01/06 17:12:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:12:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:12:50] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:12:51] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:13:59] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:14:00] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:14:00] detectron2 INFO: Command line arguments: None +[01/06 17:14:00] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:14:00] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:14:00] d2.utils.env INFO: Using a generated random seed 549034 +[01/06 17:14:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:14:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:14:00] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:14:01] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:18:37] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:18:38] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:18:38] detectron2 INFO: Command line arguments: None +[01/06 17:18:38] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:18:38] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:18:38] d2.utils.env INFO: Using a generated random seed 38313788 +[01/06 17:18:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:18:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:18:38] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:18:39] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:19:31] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:19:32] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:19:32] detectron2 INFO: Command line arguments: None +[01/06 17:19:32] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:19:32] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:19:32] d2.utils.env INFO: Using a generated random seed 32914491 +[01/06 17:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:19:32] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:19:34] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) +[01/06 17:20:23] detectron2 INFO: Rank of current process: 0. World size: 1 +[01/06 17:20:24] detectron2 INFO: Environment info: +---------------------- -------------------------------------------------------------------------- +sys.platform linux +Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56) [GCC 7.2.0] +numpy 1.19.5 +detectron2 0.3 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/detectron2 +Compiler GCC 7.3 +CUDA compiler CUDA 10.2 +detectron2 arch flags 3.7, 5.0, 5.2, 6.0, 6.1, 7.0, 7.5 +DETECTRON2_ENV_MODULE +PyTorch 1.7.1 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torch +PyTorch debug build False +GPU available True +GPU 0,1,2,3 Tesla V100-SXM2-32GB (arch=7.0) +CUDA_HOME /usr/local/cuda-10.2 +Pillow 8.3.2 +torchvision 0.8.2 @/data/home/sxhong/anaconda3/lib/python3.6/site-packages/torchvision +torchvision arch flags 3.5, 5.0, 6.0, 7.0, 7.5 +fvcore 0.1.5.post20210825 +cv2 3.4.1 +---------------------- -------------------------------------------------------------------------- +PyTorch built with: + - GCC 7.3 + - C++ Version: 201402 + - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications + - Intel(R) MKL-DNN v1.6.0 (Git Hash 5ef631a030a6f73131c77892041042805a06064f) + - OpenMP 201511 (a.k.a. OpenMP 4.5) + - NNPACK is enabled + - CPU capability usage: AVX2 + - CUDA Runtime 10.2 + - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75 + - CuDNN 7.6.5 + - Magma 2.5.2 + - Build settings: BLAS=MKL, BUILD_TYPE=Release, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DUSE_VULKAN_WRAPPER -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-sign-compare -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Wno-stringop-overflow, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, USE_CUDA=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, + +[01/06 17:20:24] detectron2 INFO: Command line arguments: None +[01/06 17:20:24] detectron2 INFO: Running with full config: +CUDNN_BENCHMARK: False +DATALOADER: + ASPECT_RATIO_GROUPING: True + FILTER_EMPTY_ANNOTATIONS: True + NUM_WORKERS: 4 + REPEAT_THRESHOLD: 0.0 + SAMPLER_TRAIN: TrainingSampler +DATASETS: + PRECOMPUTED_PROPOSAL_TOPK_TEST: 1000 + PRECOMPUTED_PROPOSAL_TOPK_TRAIN: 2000 + PROPOSAL_FILES_TEST: () + PROPOSAL_FILES_TRAIN: () + TEST: () + TRAIN: () +GLOBAL: + HACK: 1.0 +INPUT: + CROP: + ENABLED: False + SIZE: [0.9, 0.9] + TYPE: relative_range + FORMAT: BGR + MASK_FORMAT: polygon + MAX_SIZE_TEST: 1000 + MAX_SIZE_TRAIN: 1000 + MIN_SIZE_TEST: 600 + MIN_SIZE_TRAIN: (600,) + MIN_SIZE_TRAIN_SAMPLING: choice + RANDOM_FLIP: horizontal +MODEL: + ANCHOR_GENERATOR: + ANGLES: [[-90, 0, 90]] + ASPECT_RATIOS: [[0.5, 1.0, 2.0]] + NAME: DefaultAnchorGenerator + OFFSET: 0.0 + SIZES: [[4, 8, 16, 32]] + BACKBONE: + FREEZE_AT: 3 + NAME: build_bua_resnet_backbone + BUA: + ATTRIBUTE: + NUM_CLASSES: 401 + ATTRIBUTE_ON: True + CAFFE: True + EXTRACTOR: + CONF_THRESH: 0.4 + MAX_BOXES: 45 + MIN_BOXES: 5 + MODE: 2 + OUTPUT_DIR: .output/ + EXTRACT_FEATS: True + RESNET_VERSION: 1 + RPN: + CONV_OUT_CHANNELS: 512 + DEVICE: cuda + FPN: + FUSE_TYPE: sum + IN_FEATURES: [] + NORM: + OUT_CHANNELS: 256 + KEYPOINT_ON: False + LOAD_PROPOSALS: False + MASK_ON: False + META_ARCHITECTURE: GeneralizedBUARCNN + PANOPTIC_FPN: + COMBINE: + ENABLED: True + INSTANCES_CONFIDENCE_THRESH: 0.5 + OVERLAP_THRESH: 0.5 + STUFF_AREA_LIMIT: 4096 + INSTANCE_LOSS_WEIGHT: 1.0 + PIXEL_MEAN: [102.9801, 115.9465, 122.7717] + PIXEL_STD: [1.0, 1.0, 1.0] + PROPOSAL_GENERATOR: + MIN_SIZE: 16 + NAME: BUARPN + RESNETS: + DEFORM_MODULATED: False + DEFORM_NUM_GROUPS: 1 + DEFORM_ON_PER_STAGE: [False, False, False, False] + DEPTH: 101 + NORM: BN + NUM_GROUPS: 1 + OUT_FEATURES: ['res4'] + RES2_OUT_CHANNELS: 256 + RES5_DILATION: 2 + STEM_OUT_CHANNELS: 64 + STRIDE_IN_1X1: True + WIDTH_PER_GROUP: 64 + RETINANET: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + FOCAL_LOSS_ALPHA: 0.25 + FOCAL_LOSS_GAMMA: 2.0 + IN_FEATURES: ['p3', 'p4', 'p5', 'p6', 'p7'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.4, 0.5] + NMS_THRESH_TEST: 0.5 + NORM: + NUM_CLASSES: 80 + NUM_CONVS: 4 + PRIOR_PROB: 0.01 + SCORE_THRESH_TEST: 0.05 + SMOOTH_L1_LOSS_BETA: 0.1 + TOPK_CANDIDATES_TEST: 1000 + ROI_BOX_CASCADE_HEAD: + BBOX_REG_WEIGHTS: ((10.0, 10.0, 5.0, 5.0), (20.0, 20.0, 10.0, 10.0), (30.0, 30.0, 15.0, 15.0)) + IOUS: (0.5, 0.6, 0.7) + ROI_BOX_HEAD: + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + CLS_AGNOSTIC_BBOX_REG: False + CONV_DIM: 256 + FC_DIM: 1024 + NAME: + NORM: + NUM_CONV: 0 + NUM_FC: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIPool + SMOOTH_L1_BETA: 0.0 + TRAIN_ON_PRED_BOXES: False + ROI_HEADS: + BATCH_SIZE_PER_IMAGE: 64 + IN_FEATURES: ['res4'] + IOU_LABELS: [0, 1] + IOU_THRESHOLDS: [0.5] + NAME: BUACaffeRes5ROIHeads + NMS_THRESH_TEST: 0.3 + NUM_CLASSES: 1601 + POSITIVE_FRACTION: 0.5 + PROPOSAL_APPEND_GT: True + SCORE_THRESH_TEST: -1.0 + ROI_KEYPOINT_HEAD: + CONV_DIMS: (512, 512, 512, 512, 512, 512, 512, 512) + LOSS_WEIGHT: 1.0 + MIN_KEYPOINTS_PER_IMAGE: 1 + NAME: KRCNNConvDeconvUpsampleHead + NORMALIZE_LOSS_BY_VISIBLE_KEYPOINTS: True + NUM_KEYPOINTS: 17 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + ROI_MASK_HEAD: + CLS_AGNOSTIC_MASK: False + CONV_DIM: 256 + NAME: MaskRCNNConvUpsampleHead + NORM: + NUM_CONV: 0 + POOLER_RESOLUTION: 14 + POOLER_SAMPLING_RATIO: 0 + POOLER_TYPE: ROIAlignV2 + RPN: + BATCH_SIZE_PER_IMAGE: 64 + BBOX_REG_LOSS_TYPE: smooth_l1 + BBOX_REG_LOSS_WEIGHT: 1.0 + BBOX_REG_WEIGHTS: (1.0, 1.0, 1.0, 1.0) + BOUNDARY_THRESH: -1 + HEAD_NAME: StandardBUARPNHead + IN_FEATURES: ['res4'] + IOU_LABELS: [0, -1, 1] + IOU_THRESHOLDS: [0.3, 0.7] + LOSS_WEIGHT: 1.0 + NMS_THRESH: 0.7 + POSITIVE_FRACTION: 0.5 + POST_NMS_TOPK_TEST: 300 + POST_NMS_TOPK_TRAIN: 2000 + PRE_NMS_TOPK_TEST: 6000 + PRE_NMS_TOPK_TRAIN: 12000 + SMOOTH_L1_BETA: 0.0 + SEM_SEG_HEAD: + COMMON_STRIDE: 4 + CONVS_DIM: 128 + IGNORE_VALUE: 255 + IN_FEATURES: ['p2', 'p3', 'p4', 'p5'] + LOSS_WEIGHT: 1.0 + NAME: SemSegFPNHead + NORM: GN + NUM_CLASSES: 54 + WEIGHTS: ./bbox_extractor/weights/bua-caffe-frcn-r101_with_attributes.pth +OUTPUT_DIR: ./output +SEED: -1 +SOLVER: + AMP: + ENABLED: False + BASE_LR: 0.001 + BIAS_LR_FACTOR: 1.0 + CHECKPOINT_PERIOD: 5000 + CLIP_GRADIENTS: + CLIP_TYPE: value + CLIP_VALUE: 1.0 + ENABLED: False + NORM_TYPE: 2.0 + GAMMA: 0.1 + IMS_PER_BATCH: 16 + LR_SCHEDULER_NAME: WarmupMultiStepLR + MAX_ITER: 40000 + MOMENTUM: 0.9 + NESTEROV: False + REFERENCE_WORLD_SIZE: 0 + STEPS: (30000,) + WARMUP_FACTOR: 0.001 + WARMUP_ITERS: 1000 + WARMUP_METHOD: linear + WEIGHT_DECAY: 0.0001 + WEIGHT_DECAY_BIAS: 0.0001 + WEIGHT_DECAY_NORM: 0.0 +TEST: + AUG: + ENABLED: False + FLIP: True + MAX_SIZE: 4000 + MIN_SIZES: (400, 500, 600, 700, 800, 900, 1000, 1100, 1200) + DETECTIONS_PER_IMAGE: 100 + EVAL_PERIOD: 0 + EXPECTED_RESULTS: [] + KEYPOINT_OKS_SIGMAS: [] + PRECISE_BN: + ENABLED: False + NUM_ITER: 200 +VERSION: 2 +VIS_PERIOD: 0 +[01/06 17:20:24] detectron2 INFO: Full config saved to ./output/config.yaml +[01/06 17:20:24] d2.utils.env INFO: Using a generated random seed 24328143 +[01/06 17:20:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:20:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:20:24] d2.modeling.backbone.resnet WARNING: ResNet.make_stage(first_stride=) is deprecated! Use 'stride_per_block' or 'stride' instead. +[01/06 17:20:25] d2.engine.defaults INFO: Model: +GeneralizedBUARCNN( + (backbone): ResNet( + (stem): BUABasicStem( + (conv1): Conv2d( + 3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + ) + (res2): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + (conv1): Conv2d( + 64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv2): Conv2d( + 64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=64, eps=1e-05) + ) + (conv3): Conv2d( + 64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=256, eps=1e-05) + ) + ) + ) + (res3): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + (conv1): Conv2d( + 256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv2): Conv2d( + 128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=128, eps=1e-05) + ) + (conv3): Conv2d( + 128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): FrozenBatchNorm2d(num_features=512, eps=1e-05) + ) + ) + ) + (res4): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (3): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (4): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (5): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (6): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (7): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (8): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (9): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (10): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (11): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (12): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (13): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (14): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (15): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (16): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (17): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (18): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (19): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (20): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (21): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (22): BottleneckBlock( + (conv1): Conv2d( + 1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False + (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + ) + (proposal_generator): BUARPN( + (anchor_generator): DefaultAnchorGenerator( + (cell_anchors): BufferList() + ) + (rpn_head): StandardBUARPNHead( + (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) + (objectness_logits): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1)) + (anchor_deltas): Conv2d(512, 48, kernel_size=(1, 1), stride=(1, 1)) + ) + ) + (roi_heads): BUACaffeRes5ROIHeads( + (pooler): ROIPooler( + (level_poolers): ModuleList( + (0): RoIPool(output_size=(14, 14), spatial_scale=0.0625) + ) + ) + (res5): Sequential( + (0): BottleneckBlock( + (shortcut): Conv2d( + 1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv1): Conv2d( + 1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (1): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + (2): BottleneckBlock( + (conv1): Conv2d( + 2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv2): Conv2d( + 512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False + (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + (conv3): Conv2d( + 512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False + (norm): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) + ) + ) + ) + (box_predictor): BUACaffeFastRCNNOutputLayers( + (cls_score): Linear(in_features=2048, out_features=1601, bias=True) + (bbox_pred): Linear(in_features=2048, out_features=6404, bias=True) + (cls_embed): Embedding(1601, 256) + (attr_linear1): Linear(in_features=2304, out_features=512, bias=True) + (attr_linear2): Linear(in_features=512, out_features=401, bias=True) + ) + ) +) diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/text_feat_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/text_feat_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..e8b5508e3286e46cc0c61d339a90529878d9e854 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/text_feat_extractor.py @@ -0,0 +1,110 @@ +# -*- encoding: utf-8 -*- +''' +@File : text_feat_extractor.py +@Time : 2021/08/26 10:46:15 +@Author : Chuhao Jin +@Email : jinchuhao@ruc.edu.cn +''' + +# here put the import lib + +import os +import sys +import pickle +import argparse +base_dir = os.path.abspath(os.path.dirname(__file__)) +sys.path.append(base_dir) +import torch +import torch.nn as nn +import torchvision.transforms as transforms +import numpy as np +from transformers import AutoTokenizer + +from utils import getLanMask +from utils.config import cfg_from_yaml_file, cfg +from models.vl_model import * +from tqdm import tqdm +import pdb + +class TextModel(nn.Module): + def __init__(self, model_cfg): + super(TextModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['textencoder'] = TextLearnableEncoder(model_cfg) + + def forward(self, texts, maskTexts): + textFea = self.learnable['textencoder'](texts, maskTexts) # + textFea = F.normalize(textFea, p=2, dim=-1) + return textFea + +class TextFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id = 0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.cfg.MODEL.ENCODER = os.path.join(base_dir, self.cfg.MODEL.ENCODER) + self.text_model = TextModel(model_cfg=self.cfg.MODEL) + + self.text_model = self.text_model.cuda(self.gpu_id) + model_component = torch.load(model_weights, map_location=torch.device('cuda:{}'.format(self.gpu_id))) + text_model_component = {} + for key in model_component["learnable"].keys(): + if "textencoder." in key: + text_model_component[key] = model_component["learnable"][key] + self.text_model.learnable.load_state_dict(text_model_component) + self.text_model.eval() + + self.text_transform = AutoTokenizer.from_pretrained('./hfl/chinese-bert-wwm-ext') + + def extract(self, text_input): + if text_input is None: + return None + else: + text_info = self.text_transform(text_input, padding='max_length', truncation=True, + max_length=self.cfg.MODEL.MAX_TEXT_LEN, return_tensors='pt') + text = text_info.input_ids.reshape(-1) + text_len = torch.sum(text_info.attention_mask) + with torch.no_grad(): + texts = text.unsqueeze(0) + text_lens = text_len.unsqueeze(0) + textMask = getLanMask(text_lens, cfg.MODEL.MAX_TEXT_LEN) + textMask = textMask.cuda(self.gpu_id) + texts = texts.cuda(self.gpu_id) + text_lens = text_lens.cuda(self.gpu_id) + text_fea = self.text_model(texts, textMask) + text_fea = text_fea.cpu().numpy() + return text_fea + + +if __name__ == '__main__': + parser = argparse.ArgumentParser() + parser.add_argument('--txt_path', type=str, default=None) + parser.add_argument('--feat_save_dir', type=str, default=None) + parser.add_argument('--cfg_file', type=str, default='cfg/test_xyb.yml') + parser.add_argument('--brivl_checkpoint', type=str, default='/data_share7/sxhong/project/BriVL/weights/BriVL-1.0-5500w.pth') + args = parser.parse_args() + + cfg_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), args.cfg_file) + model_weights = args.brivl_checkpoint + save_dir = args.feat_save_dir + vfe = TextFeatureExtractor(cfg_file, model_weights) + if not os.path.exists(args.feat_save_dir): + os.makedirs(args.feat_save_dir) + for line in open(args.txt_path): + try: + songid, text = line.split(',')[0], line.split('"')[1] + save_path = os.path.join(save_dir, songid + '.npy') + if not os.path.exists(save_path): + text = text.split(',') + if len(text) >= 5: + mid = len(text) // 2 + text = text[mid-2: mid+2] + text_query = ','.join(text) + fea = vfe.extract(text_query) + np.save(save_path, fea) + except: + pass + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/__init__.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..250fbc160b91c0ab12584dc4aa8fa0ed285bfa8e --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/__init__.py @@ -0,0 +1 @@ +from .loss import pairLoss, alignmentLoss, attAlignmentLoss, AlignTripLoss, SimpTripLoss, NCELoss, getLanMask diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/config.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/config.py new file mode 100755 index 0000000000000000000000000000000000000000..5eebbca4d9fc43b4a88b4bd5c1adee7650a5947f --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/config.py @@ -0,0 +1,93 @@ +from pathlib import Path + +import yaml +from easydict import EasyDict + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def log_config_to_file(cfg, pre="cfg", logger=None): + for key, val in cfg.items(): + if isinstance(cfg[key], EasyDict): + logger.info("\n%s.%s = edict()" % (pre, key)) + log_config_to_file(cfg[key], pre=pre + "." + key, logger=logger) + continue + logger.info("%s.%s: %s" % (pre, key, val)) + + +def cfg_from_list(cfg_list, config): + """Set config keys via list (e.g., from command line).""" + from ast import literal_eval + + assert len(cfg_list) % 2 == 0 + for k, v in zip(cfg_list[0::2], cfg_list[1::2]): + key_list = k.split(".") + d = config + for subkey in key_list[:-1]: + assert subkey in d, "NotFoundKey: %s" % subkey + d = d[subkey] + subkey = key_list[-1] + assert subkey in d, "NotFoundKey: %s" % subkey + try: + value = literal_eval(v) + except: + value = v + + if type(value) != type(d[subkey]) and isinstance(d[subkey], EasyDict): + key_val_list = value.split(",") + for src in key_val_list: + cur_key, cur_val = src.split(":") + val_type = type(d[subkey][cur_key]) + cur_val = val_type(cur_val) + d[subkey][cur_key] = cur_val + elif type(value) != type(d[subkey]) and isinstance(d[subkey], list): + val_list = value.split(",") + for k, x in enumerate(val_list): + val_list[k] = type(d[subkey][0])(x) + d[subkey] = val_list + else: + assert type(value) == type( + d[subkey] + ), "type {} does not match original type {}".format( + type(value), type(d[subkey]) + ) + d[subkey] = value + + +def merge_new_config(config, new_config): + if "_BASE_CONFIG_" in new_config: + with open(new_config["_BASE_CONFIG_"], "r") as f: + try: + yaml_config = yaml.load(f, Loader=yaml.FullLoader) + except: + yaml_config = yaml.load(f) + config.update(EasyDict(yaml_config)) + + for key, val in new_config.items(): + if not isinstance(val, dict): + config[key] = val + continue + if key not in config: + config[key] = EasyDict() + merge_new_config(config[key], val) + + return config + + +def cfg_from_yaml_file(cfg_file, config): + with open(cfg_file, "r") as f: + try: + new_config = yaml.load(f, Loader=yaml.FullLoader) + except: + new_config = yaml.load(f) + + merge_new_config(config=config, new_config=new_config) + + return config + + +cfg = EasyDict() +cfg.ROOT_DIR = (Path(__file__).resolve().parent / "../").resolve() +# cfg.LOCAL_RANK = 0 diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/get_lyrics.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/get_lyrics.py new file mode 100755 index 0000000000000000000000000000000000000000..32c6699442ab5e72bae361141f57d4ca0b107e1d --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/get_lyrics.py @@ -0,0 +1,49 @@ +import pandas as pd +import numpy as np +import requests +import os +import csv +import argparse +# your settings +parser = argparse.ArgumentParser() +parser.add_argument('--csv_file', type=str, default=None) +parser.add_argument('--output_file', type=str, default=None) +parser.add_argument('--token', type=str, default='songid') +parser.add_argument('--lyric_batch_size', type=int, default=100) +args = parser.parse_args() + +csv_path = args.csv_file +output_file = args.output_file + +writer = csv.writer(open(output_file, 'w')) +sep = ',' + +batch_size = args.lyric_batch_size + +def main(): + df = pd.read_csv(csv_path) + songids = df[args.token].astype(str).tolist() +# tags = df.genre.astype(str).tolist() + print('total {} samples to extract ...'.format(len(songids))) + + n_batch = int(len(songids)/batch_size) + 1 + n = 0 + zh_k = 0 + for i in range(n_batch): + sub_songids = songids[i*batch_size:(i+1)*batch_size] + resq_params = {'id': ', '.join(sub_songids), 'clean': 'deep'} + resq = requests.post('http://11.181.92.137:8080/lyric_pull', json=resq_params) + results = resq.json() + for j in range(len(results)): + if results[j]['lyric'] != '': + line = [results[j]['id'], results[j]['lyric']] + writer.writerow(line) + else: + pass + n = n + 1 + print('finish {} samples ...'.format(n)) + + + +if __name__ == '__main__': + main() diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/loss.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/loss.py new file mode 100755 index 0000000000000000000000000000000000000000..e9be8873968d1b5f6c1a29e43a3aa876d50c8214 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/utils/loss.py @@ -0,0 +1,217 @@ +import torch +import torch.nn.functional as F + + +def pairLoss(fea1, fea2, mask): + # fea1_size (bs, max_len, dim) + # fea2_size (bs, max_len, dim) + # mask_size (bs, max_len) + # '-Inf' for padded item, '0' for others + + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + fea_sim = (fea1 * fea2).sum(dim=-1) # (bs, max_len) + fea_sim = torch.masked_select(fea_sim, mask == 0) + loss = 1.0 - torch.mean(fea_sim) + return loss + + +def SimpTripLoss(fea1, fea2): + # img fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # text fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + # fea1 = fea1.mean(dim=1) #(bs, dim) + # mask2 = torch.where(mask2==0, torch.tensor([1.0],device=mask2.device), torch.tensor([0.0],device=mask2.device)) + # fea2 = (fea2 * mask2.unsqueeze(-1)).sum(dim=1) / mask2.sum(dim=1).unsqueeze(-1) #(bs, dim) + + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + + # match fea1 to fea2 + sim_pos1 = (fea1 * fea2).sum(dim=1) # (bs) + # (bs, 1, dim) (1, bs, dim) + sim_neg1_all = (fea1.unsqueeze(1) * fea2.unsqueeze(0)).sum(dim=-1) # (bs,bs) + unmask = torch.eye(sim_pos1.size(0), dtype=torch.float32, device=sim_pos1.device) + unmask = torch.where(unmask == 1, torch.tensor([float('-Inf')], device=unmask.device), unmask) + + sim_neg1, _ = torch.max(sim_neg1_all + unmask, 1) + loss1 = -sim_pos1 + sim_neg1 + 0.2 + loss1 = torch.maximum(loss1, torch.zeros_like(loss1)).mean() + + # match fea2 to fea1 + sim_pos2 = (fea2 * fea1).sum( + dim=1) # (bs) sim_neg2_all = (fea2.unsqueeze(1) * fea1.unsqueeze(0)).sum(dim=-1) #(bs,bs) + sim_neg2_all = (fea2.unsqueeze(1) * fea1.unsqueeze(0)).sum(dim=-1) # (bs,bs) + + sim_neg2, _ = torch.max(sim_neg2_all + unmask, 1) + loss2 = -sim_pos2 + sim_neg2 + 0.2 + loss2 = torch.maximum(loss2, torch.zeros_like(loss2)).mean() + + loss = loss1 + loss2 + return loss + + +def NCELoss(fea1, fea2): + # img fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # text fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + # fea1 = fea1.mean(dim=1) #(bs, dim) + # mask2 = torch.where(mask2==0, torch.tensor([1.0],device=mask2.device), torch.tensor([0.0],device=mask2.device)) + # fea2 = (fea2 * mask2.unsqueeze(-1)).sum(dim=1) / mask2.sum(dim=1).unsqueeze(-1) #(bs, dim) + + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + + # match fea1 to fea2 + sim_pos1 = (fea1 * fea2).sum(dim=1).unsqueeze(-1) # (bs,1) + BS = sim_pos1.size(0) + # (bs, 1, dim) (1, bs, dim) + sim_neg1_all = (fea1.unsqueeze(1) * fea2.unsqueeze(0)).sum(dim=-1) # (bs,bs) + unmask = torch.eye(sim_pos1.size(0), dtype=torch.float32, device=sim_pos1.device) + sim_neg1_all = torch.masked_select(sim_neg1_all, unmask == 0).view(BS, BS - 1) # (bs, bs-1) + sim1_pos_neg = torch.cat((sim_pos1, sim_neg1_all), dim=1) / 0.07 # (bs, bs) + loss1 = -F.log_softmax(sim1_pos_neg, dim=1)[:, 0].mean() + + # match fea2 to fea1 + sim_pos2 = (fea2 * fea1).sum(dim=1).unsqueeze(-1) # (bs,1) + sim_neg2_all = (fea2.unsqueeze(1) * fea1.unsqueeze(0)).sum(dim=-1) # (bs,bs) + sim_neg2_all = torch.masked_select(sim_neg2_all, unmask == 0).view(BS, BS - 1) # (bs, bs-1) + sim2_pos_neg = torch.cat((sim_pos2, sim_neg2_all), dim=1) / 0.07 # (bs, bs) + loss2 = -F.log_softmax(sim2_pos_neg, dim=1)[:, 0].mean() + + loss = (loss1 + loss2) / 2.0 + return loss + + +def AlignTripLoss(fea1, fea2, mask1, mask2): + # fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + + # match fea1 to fea2 + sim_pos1 = cal_sim(fea1, fea2, mask1, mask2) # (bs) + # (bs, 1, max_len1, dim) (1, bs, max_len2, dim) + sim_neg1_all = cal_sim_all(fea1.unsqueeze(1), fea2.unsqueeze(0), mask1, mask2) # (bs,bs) + unmask = torch.eye(sim_pos1.size(0), dtype=torch.float32, device=sim_pos1.device) + unmask = torch.where(unmask == 1, torch.tensor([float('-Inf')], device=unmask.device), unmask) + + sim_neg1, _ = torch.max(sim_neg1_all + unmask, 1) + loss1 = -sim_pos1 + sim_neg1 + 0.2 + loss1 = torch.maximum(loss1, torch.zeros_like(loss1)).mean() + + # match fea2 to fea1 + sim_pos2 = cal_sim(fea2, fea1, mask2, mask1) # (bs) + # (bs, 1, max_len1, dim) (1, bs, max_len2, dim) + sim_neg2_all = cal_sim_all(fea2.unsqueeze(1), fea1.unsqueeze(0), mask2, mask1) # (bs,bs) + sim_neg2, _ = torch.max(sim_neg2_all + unmask, 1) + loss2 = -sim_pos2 + sim_neg2 + 0.2 + loss2 = torch.maximum(loss2, torch.zeros_like(loss2)).mean() + + loss = loss1 + loss2 + + return loss + + +def cal_sim_all(fea1, fea2, mask1, mask2): + # fea1_size (bs, 1, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (1, bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + max_len1 = fea1.size(2) + max_len2 = fea2.size(2) + bs = fea1.size(0) + fea1_tmp = fea1.unsqueeze(3) # (bs, 1, max_len1, 1, dim) + fea2_tmp = fea2.unsqueeze(2) # (1, bs, 1, max_len2, dim) + fea_sim = (fea1_tmp * fea2_tmp).sum(dim=-1) # (bs, bs, max_len1, max_len2) + + fea_sim = fea_sim + mask2.unsqueeze(dim=1) # (bs, bs, max_len1, max_len2) + idxs = torch.argmax(fea_sim, dim=-1).view(-1).unsqueeze(-1) # (bs*bs*max_len1, 1) + fea_sim = fea_sim.view(-1, max_len2) # (bs*bs*max_len1, max_len2) + select_sim = torch.gather(fea_sim, 1, idxs).view(bs, bs, max_len1) # (bs, bs, max_len1) + mask1_mult = torch.where(mask1 == 0, torch.tensor([1.0], device=mask1.device), + torch.tensor([0.0], device=mask1.device)).unsqueeze(1) # (bs, 1, max_len1) + select_sim = (select_sim * mask1_mult).sum(dim=-1) / mask1_mult.sum(dim=-1) # (bs, bs) + + return select_sim + + +def cal_sim(fea1, fea2, mask1, mask2): + # fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + max_len1 = fea1.size(1) + max_len2 = fea2.size(1) + fea1_tmp = fea1.unsqueeze(2) # (bs, max_len1, 1, dim) + fea2_tmp = fea2.unsqueeze(1) # (bs, 1, max_len2, dim) + fea_sim = (fea1_tmp * fea2_tmp).sum(dim=-1) # (bs, max_len1, max_len2) + + fea_sim = fea_sim + mask2.unsqueeze(dim=1) # (bs, max_len1, max_len2) + idxs = torch.argmax(fea_sim, dim=-1).view(-1).unsqueeze(-1) # (bs*max_len1, 1) + fea_sim = fea_sim.view(-1, max_len2) # (bs*max_len1, max_len2) + select_sim = torch.gather(fea_sim, 1, idxs).view(-1, max_len1) # (bs, max_len1) + mask1_mult = torch.where(mask1 == 0, 1, 0) + select_sim = (select_sim * mask1_mult).sum(dim=-1) / mask1_mult.sum(dim=-1) # (bs) + + return select_sim + + +def alignmentLoss(fea1, fea2, mask1, mask2): + # fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + loss1 = alignSingleLoss(fea1, fea2, mask1, mask2) + loss2 = alignSingleLoss(fea2, fea1, mask2, mask1) + loss = (loss1 + loss2) / 2.0 + return loss + + +def attAlignmentLoss(fea1, fea2, mask1, mask2, attFc): + # fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + + fea1 = F.normalize(fea1, p=2, dim=-1) + fea2 = F.normalize(fea2, p=2, dim=-1) + fea1_tmp = fea1.unsqueeze(2) # (bs, max_len1, 1, dim) + fea2_tmp = fea2.unsqueeze(1) # (bs, 1, max_len2, dim) + fea_sim = fea1_tmp * fea2_tmp + att_sim = attFc(fea_sim).squeeze(-1) # (bs, max_len1, max_len2) + fea_sim = fea_sim.sum(dim=-1) # (bs, max_len1, max_len2) + fea_sim = fea_sim * att_sim # (bs, max_len1, max_len2) + + ###Simple as max_len1=49 + loss = torch.masked_select(fea_sim, (mask2 == 0).unsqueeze(1)) + loss = 1.0 - loss.mean() + + return loss + + +def alignSingleLoss(fea1, fea2, mask1, mask2): + # fea1_size (bs, max_len1, dim) mask1_size (bs, max_len1) + # fea2_size (bs, max_len2, dim) mask2_size (bs, max_len2) + # '-Inf' for padded item, '0' for others + + fea1_tmp = fea1.unsqueeze(2) # (bs, max_len1, 1, dim) + fea2_tmp = fea2.unsqueeze(1) # (bs, 1, max_len2, dim) + fea_sim = (fea1_tmp * fea2_tmp).sum(dim=-1) # (bs, max_len1, max_len2) + fea_sim = fea_sim + mask2.unsqueeze(dim=1) # (bs, max_len1, max_len2) + idxs = torch.argmax(fea_sim, dim=-1).view(-1).unsqueeze(-1) # (bs*max_len1, 1) + fea_sim = fea_sim.view(-1, fea_sim.size(-1)) # (bs*max_len1, max_len2) + + select_sim = torch.gather(fea_sim, 1, idxs).view(-1) # (bs*max_len1) + select_sim = torch.masked_select(select_sim, (mask1 == 0).view(-1)) + loss = 1.0 - torch.mean(select_sim) + return loss + + +def getLanMask(seq_lens, max_len): + # seq_lens (bs) + mask = torch.ones((seq_lens.size(0), max_len)) # (bs, max_len) + idxs = torch.arange(max_len).unsqueeze(dim=0) # (1, max_len) + seq_lens = seq_lens.unsqueeze(-1) # (bs, 1) + mask = torch.where(idxs < seq_lens, mask, torch.Tensor([0.0])) + return mask diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/video_feat_extractor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/video_feat_extractor.py new file mode 100755 index 0000000000000000000000000000000000000000..63eefa22f0551f5df4d5a1735b587d77a83f41fe --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/video_feat_extractor.py @@ -0,0 +1,149 @@ +# -*- encoding: utf-8 -*- +# here put the import lib + +import os +import sys +import argparse +import torch +import torch.nn as nn +import torchvision.transforms as transforms +import numpy as np +from PIL import Image +from utils import getLanMask +from utils.config import cfg_from_yaml_file, cfg +from models.vl_model import * +import glob +from tqdm import tqdm +import pickle +import json +import cv2 +from torchvision.ops import nms +from bbox_extractor.bbox_extractor import BboxExtractor +import parser +import pandas as pd +import random +import pdb +from img_feat_extractor import generate_folder_csv + + +class ImgModel(nn.Module): + def __init__(self, model_cfg): + super(ImgModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable['imgencoder'] = ImgLearnableEncoder(model_cfg) + + def forward(self, imgFea, maskImages, image_boxs): + imgFea = self.learnable['imgencoder'](imgFea, maskImages, image_boxs) # + imgFea = F.normalize(imgFea, p=2, dim=-1) + return imgFea + +class ImgFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id = 0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.img_model = ImgModel(model_cfg=self.cfg.MODEL) + + self.img_model = self.img_model.cuda(self.gpu_id) + model_component = torch.load(model_weights, map_location=torch.device('cuda:{}'.format(self.gpu_id))) + img_model_component = {} + for key in model_component["learnable"].keys(): + if "imgencoder." in key: + img_model_component[key] = model_component["learnable"][key] + self.img_model.learnable.load_state_dict(img_model_component) + self.img_model.eval() + self.visual_transform = self.visual_transforms_box(self.cfg.MODEL.IMG_SIZE) + + def visual_transforms_box(self, new_size = 456): + mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] + normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + + return transforms.Compose([ + transforms.ToTensor(), + transforms.Resize((new_size, new_size)), + normalize]) + + def extract(self, img_path, bboxes): + image = Image.open(img_path).convert('RGB') + if image is None: + return None + else: + width, height = image.size + new_size = self.cfg.MODEL.IMG_SIZE + img_box_s = [] + for box_i in bboxes[:self.cfg.MODEL.MAX_IMG_LEN-1]: # [x1, y1, x2, y2] + x1, y1, x2, y2 = box_i[0] * (new_size/width), box_i[1] * (new_size/height), box_i[2] * (new_size/width), box_i[3] * (new_size/height) + img_box_s.append(torch.from_numpy(np.array([x1, y1, x2, y2]).astype(np.float32))) + img_box_s.append(torch.from_numpy(np.array([0, 0, new_size, new_size]).astype(np.float32))) + + image_boxs = torch.stack(img_box_s, 0) # <36, 4> + image = self.visual_transform(image) + img_len = torch.full((1,), self.cfg.MODEL.MAX_IMG_LEN, dtype=torch.long) + + with torch.no_grad(): + imgs = image.unsqueeze(0) # + img_lens = img_len.unsqueeze(0).view(-1) + image_boxs = image_boxs.unsqueeze(0) # + + # get image mask + imgMask = getLanMask(img_lens, cfg.MODEL.MAX_IMG_LEN) + imgMask = imgMask.cuda(self.gpu_id) + + imgs = imgs.cuda(self.gpu_id) + image_boxs = image_boxs.cuda(self.gpu_id) # + img_fea = self.img_model(imgs, imgMask, image_boxs) + img_fea = img_fea.cpu().numpy() + return img_fea + + + +if __name__ == '__main__': + # python img_feat_extractor.py --frames_dir ./frames --vid_dir /data_share5/douyin/video --vid_csv_path ./vids.csv --feat_save_dir feats + parser = argparse.ArgumentParser() + parser.add_argument('--frames_dir', type=str, default=None) + parser.add_argument('--vid_csv_path', type=str, default=None) + parser.add_argument('--feat_save_dir', type=str, default=None) + parser.add_argument('--cfg_file', type=str, default='cfg/test_xyb.yml') + parser.add_argument('--brivl_checkpoint', type=str, default='/data_share7/sxhong/project/BriVL/weights/BriVL-1.0-5500w.pth') + parser.add_argument('--bbox_extractor_cfg', type=str, default='bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml') + + args = parser.parse_args() + abs_path = os.path.dirname(os.path.abspath(__file__)) + cfg_file = os.path.join(abs_path, args.cfg_file) + model_weights = args.brivl_checkpoint + + if not os.path.exists(args.frames_dir): + os.makedirs(args.frames_dir) + if not os.path.exists(args.feat_save_dir): + os.makedirs(args.feat_save_dir) + + vf_extractor = ImgFeatureExtractor(cfg_file, model_weights) + bbx_extr = BboxExtractor(os.path.join(abs_path, args.bbox_extractor_cfg)) + # vids = pd.read_csv(args.vid_csv_path, dtype=str)['vid'].to_list() + vids = ['/innovation_cfs/entertainment/VideoMashup/video/前任3_再见前任.mp4'] + + for vid_file_path in vids: + + vid = vid_file_path.split('/')[-1].split('.')[0] + frame_path = os.path.join(args.frames_dir, vid) + if not os.path.exists(frame_path): + os.makedirs(frame_path) + os.system('ffmpeg -i '+ vid_file_path + ' -vf fps=1 ' + frame_path +'/%d.jpg') + frame_name_list = glob.glob(os.path.join(frame_path, '*.jpg')) + frame_name_list = sorted(frame_name_list, key=lambda x:int(x.split('/')[-1].split(".")[0])) + # if len(frame_name_list) <=5: + # pass + # else: + # frame_name_list = random.sample(frame_name_list, 5) + + for frame_path in frame_name_list: + img_save_path = os.path.join(args.feat_save_dir, frame_path.split('/')[-2]+'_'+frame_path.split('/')[-1].split('.')[0]+'.npy') + bboxes = bbx_extr.extract_bboxes(frame_path) + bboxes = bboxes.tolist() + fea = vf_extractor.extract(frame_path, bboxes) + fea = fea.squeeze(axis=0) + np.save(img_save_path, fea) + diff --git a/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/wenlan_predictor.py b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/wenlan_predictor.py new file mode 100755 index 0000000000000000000000000000000000000000..ccde30be125c694a6fb11e003b05365423386609 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/feature_extractor/wenlan/wenlan_predictor.py @@ -0,0 +1,216 @@ +# -*- encoding: utf-8 -*- +# here put the import lib + +import os +import sys +import argparse +import glob +import pickle +import json +import cv2 +import parser +import random +import pdb +import traceback +import hashlib + +from moviepy.editor import VideoFileClip +from tqdm import tqdm +import pandas as pd +import numpy as np +from PIL import Image +import torch +import torch.nn as nn +import torchvision.transforms as transforms +from torchvision.ops import nms + +try: + from ..wenlan.bbox_extractor.bbox_extractor import BboxExtractor + from ..wenlan.img_feat_extractor import generate_folder_csv + from ..wenlan.utils import getLanMask + from ..wenlan.utils.config import cfg_from_yaml_file, cfg + from ..wenlan.models.vl_model import * +except: + pass + + +class ImgModel(nn.Module): + def __init__(self, model_cfg): + super(ImgModel, self).__init__() + + self.model_cfg = model_cfg + + self.learnable = nn.ModuleDict() + self.learnable["imgencoder"] = ImgLearnableEncoder(model_cfg) + + def forward(self, imgFea, maskImages, image_boxs): + imgFea = self.learnable["imgencoder"]( + imgFea, maskImages, image_boxs + ) # + imgFea = F.normalize(imgFea, p=2, dim=-1) + return imgFea + + +class ImgFeatureExtractor: + def __init__(self, cfg_file, model_weights, gpu_id=0): + self.gpu_id = gpu_id + self.cfg_file = cfg_file + self.cfg = cfg_from_yaml_file(self.cfg_file, cfg) + self.img_model = ImgModel(model_cfg=self.cfg.MODEL) + + self.img_model = self.img_model.cuda(self.gpu_id) + model_component = torch.load( + model_weights, map_location=torch.device("cuda:{}".format(self.gpu_id)) + ) + img_model_component = {} + for key in model_component["learnable"].keys(): + if "imgencoder." in key: + img_model_component[key] = model_component["learnable"][key] + self.img_model.learnable.load_state_dict(img_model_component) + self.img_model.eval() + self.visual_transform = self.visual_transforms_box(self.cfg.MODEL.IMG_SIZE) + + def visual_transforms_box(self, new_size=456): + mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225] + normalize = transforms.Normalize( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + return transforms.Compose( + [transforms.ToTensor(), transforms.Resize((new_size, new_size)), normalize] + ) + + def extract(self, img_path, bboxes): + if type(img_path) == str: + image = Image.open(img_path).convert("RGB") + else: + image = Image.fromarray(img_path) + if image is None: + return None + else: + width, height = image.size + new_size = self.cfg.MODEL.IMG_SIZE + img_box_s = [] + for box_i in bboxes[: self.cfg.MODEL.MAX_IMG_LEN - 1]: # [x1, y1, x2, y2] + x1, y1, x2, y2 = ( + box_i[0] * (new_size / width), + box_i[1] * (new_size / height), + box_i[2] * (new_size / width), + box_i[3] * (new_size / height), + ) + img_box_s.append( + torch.from_numpy(np.array([x1, y1, x2, y2]).astype(np.float32)) + ) + img_box_s.append( + torch.from_numpy( + np.array([0, 0, new_size, new_size]).astype(np.float32) + ) + ) + + image_boxs = torch.stack(img_box_s, 0) # <36, 4> + image = self.visual_transform(image) + img_len = torch.full((1,), self.cfg.MODEL.MAX_IMG_LEN, dtype=torch.long) + + with torch.no_grad(): + imgs = image.unsqueeze(0) # + img_lens = img_len.unsqueeze(0).view(-1) + image_boxs = image_boxs.unsqueeze(0) # + + # get image mask + imgMask = getLanMask(img_lens, cfg.MODEL.MAX_IMG_LEN) + imgMask = imgMask.cuda(self.gpu_id) + + imgs = imgs.cuda(self.gpu_id) + image_boxs = image_boxs.cuda(self.gpu_id) # + img_fea = self.img_model(imgs, imgMask, image_boxs) + img_fea = img_fea.cpu().numpy() + return img_fea + + +def main(video_path, video_map, vf_extractor, bbx_extr): + video_name = ".".join(video_path.split("/")[-1].split(".")[:-1]) + if not os.path.exists(save_path): + os.makedirs(save_path) + # video_hash_code = (os.popen('md5sum {}'.format(video_path))).readlines()[0].split(' ')[0] + with open(video_path, "rb") as fd: + data = fd.read() + video_hash_code = hashlib.md5(data).hexdigest() + save_path = os.path.join( + save_path, "{}_{}.json".format(video_name, video_hash_code[:8]) + ) + + assert video_hash_code == video_map["video_file_hash_code"] + + fps = 1 + max_frame_num = 5 + select_frame_idx = [] + select_frame_clip = [] + for i in range(len(video_map["clips"])): + clip = video_map["clips"][i] + if clip["cliptype"] == "transition": + continue + select_frame_num = int(min(np.ceil(clip["duration"] * fps), max_frame_num)) + clip_total_frame_num = clip["frame_end"] - clip["frame_start"] + frame_duration = clip_total_frame_num // (select_frame_num + 1) + for j in range(select_frame_num): + select_frame_idx.append(clip["frame_start"] + (j + 1) * frame_duration) + select_frame_clip.append(i) + + print(len(select_frame_idx), len(set(select_frame_idx))) + + # Capture video + video = VideoFileClip(video_path) + video = video.crop(*video_map["content_box"]) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + width, height = video.size + print("fps, frame_count, width, height:", fps, total_frames, width, height) + + cnt_frame, step = 0, 0 + for frame in video.iter_frames(fps=video_map["sample_fps"]): + if step == len(select_frame_idx): + break + if cnt_frame == select_frame_idx[step]: + bboxes = bbx_extr.extract_bboxes(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)) + bboxes = bboxes.tolist() + fea = vf_extractor.extract(frame, bboxes) + fea = fea.squeeze(axis=0).tolist() + if "feat" in video_map["clips"][select_frame_clip[step]]: + video_map["clips"][select_frame_clip[step]]["feat"].append(fea) + else: + video_map["clips"][select_frame_clip[step]]["feat"] = [fea] + + step += 1 + cnt_frame += 1 + + for clip in video_map["clips"]: + clip["multi_factor"] = {"semantics": None} + if "feat" in clip: + clip["multi_factor"]["semantics"] = np.mean( + np.array(clip["feat"]), axis=0 + ).tolist() + return video_map + + +class WenLanVisualPredictor(object): + def __init__( + self, + brivl_checkpoint, + cfg_file="cfg/test_xyb.yml", + bbox_extractor_cfg="bbox_extractor/configs/bua-caffe/extract-bua-caffe-r101.yaml", + ) -> None: + # brivl_checkpoint = '/innovation_cfs/mmatch/infguo/weights/BriVL-1.0-5500w.pth', + abs_path = os.path.dirname(os.path.abspath(__file__)) + cfg_file = os.path.join(abs_path, cfg_file) + bbox_extractor_cfg = os.path.join(abs_path, bbox_extractor_cfg) + self.vf_extractor = ImgFeatureExtractor(cfg_file, brivl_checkpoint) + self.bbx_extr = BboxExtractor(bbox_extractor_cfg) + + def __call__( + self, + video_path, + video_map, + ): + video_map = main(video_path, video_map, self.vf_extractor, self.bbx_extr) + return video_map diff --git a/MuseV/MMCM/mmcm/vision/flow/__init__.py b/MuseV/MMCM/mmcm/vision/flow/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..1893d3ef22cacd1439db43db28f7f64668372f44 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/flow/__init__.py @@ -0,0 +1,2 @@ +from .util import torch_wrap, opencv_wrap +from .flow_io import write_flow, flow_from_bytes, read_flow, read_flow_kitti, write_flow_kitti, visualize_flow, flo_from_bytes, pfm_from_bytes, read_pfm, render_color_wheel \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/flow/flow_io.py b/MuseV/MMCM/mmcm/vision/flow/flow_io.py new file mode 100755 index 0000000000000000000000000000000000000000..741fb30c055d09e8f1f236766828cb83ec87a9b1 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/flow/flow_io.py @@ -0,0 +1,291 @@ +# Copyright (c) OpenMMLab. All rights reserved. +# from mmflow + +import re +from io import BytesIO +from typing import Tuple + +import cv2 +import matplotlib.pyplot as plt +import mmcv +import numpy as np +from numpy import ndarray + + +def read_flow(name: str) -> np.ndarray: + """Read flow file with the suffix '.flo'. + + This function is modified from + https://lmb.informatik.uni-freiburg.de/resources/datasets/IO.py + Copyright (c) 2011, LMB, University of Freiburg. + + Args: + name (str): Optical flow file path. + + Returns: + ndarray: Optical flow + """ + + with open(name, 'rb') as f: + + header = f.read(4) + if header.decode('utf-8') != 'PIEH': + raise Exception('Flow file header does not contain PIEH') + + width = np.fromfile(f, np.int32, 1).squeeze() + height = np.fromfile(f, np.int32, 1).squeeze() + + flow = np.fromfile(f, np.float32, width * height * 2).reshape( + (height, width, 2)) + + return flow + + +def write_flow(flow: np.ndarray, flow_file: str) -> None: + """Write the flow in disk. + + This function is modified from + https://lmb.informatik.uni-freiburg.de/resources/datasets/IO.py + Copyright (c) 2011, LMB, University of Freiburg. + + Args: + flow (ndarray): The optical flow that will be saved. + flow_file (str): The file for saving optical flow. + """ + + with open(flow_file, 'wb') as f: + f.write('PIEH'.encode('utf-8')) + np.array([flow.shape[1], flow.shape[0]], dtype=np.int32).tofile(f) + flow = flow.astype(np.float32) + flow.tofile(f) + + +def visualize_flow(flow: np.ndarray, save_file: str = None) -> np.ndarray: + """Flow visualization function. + + Args: + flow (ndarray): The flow will be render + save_dir ([type], optional): save dir. Defaults to None. + Returns: + ndarray: flow map image with RGB order. + """ + + # return value from mmcv.flow2rgb is [0, 1.] with type np.float32 + flow_map = np.uint8(mmcv.flow2rgb(flow) * 255.) + if save_file: + plt.imsave(save_file, flow_map) + return flow_map + + +def render_color_wheel(save_file: str = 'color_wheel.png') -> np.ndarray: + """Render color wheel. + + Args: + save_file (str): The saved file name . Defaults to 'color_wheel.png'. + + Returns: + ndarray: color wheel image. + """ + x0 = 75 + y0 = 75 + height = 151 + width = 151 + flow = np.zeros((height, width, 2), dtype=np.float32) + + grid_x = np.tile(np.expand_dims(np.arange(width), 0), [height, 1]) + grid_y = np.tile(np.expand_dims(np.arange(height), 1), [1, width]) + + grid_x0 = np.tile(np.array([x0]), [height, width]) + grid_y0 = np.tile(np.array([y0]), [height, width]) + + flow[:, :, 0] = grid_x - grid_x0 + flow[:, :, 1] = grid_y - grid_y0 + + return visualize_flow(flow, save_file) + + +def read_flow_kitti(name: str) -> Tuple[np.ndarray, np.ndarray]: + """Read sparse flow file from KITTI dataset. + + This function is modified from + https://github.com/princeton-vl/RAFT/blob/master/core/utils/frame_utils.py. + Copyright (c) 2020, princeton-vl + Licensed under the BSD 3-Clause License + + Args: + name (str): The flow file + + Returns: + Tuple[ndarray, ndarray]: flow and valid map + """ + # to specify not to change the image depth (16bit) + flow = cv2.imread(name, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR) + flow = flow[:, :, ::-1].astype(np.float32) + # flow shape (H, W, 2) valid shape (H, W) + flow, valid = flow[:, :, :2], flow[:, :, 2] + flow = (flow - 2**15) / 64.0 + return flow, valid + + +def write_flow_kitti(uv: np.ndarray, filename: str): + """Write the flow in disk. + + This function is modified from + https://github.com/princeton-vl/RAFT/blob/master/core/utils/frame_utils.py. + Copyright (c) 2020, princeton-vl + Licensed under the BSD 3-Clause License + + Args: + uv (ndarray): The optical flow that will be saved. + filename ([type]): The file for saving optical flow. + """ + uv = 64.0 * uv + 2**15 + valid = np.ones([uv.shape[0], uv.shape[1], 1]) + uv = np.concatenate([uv, valid], axis=-1).astype(np.uint16) + cv2.imwrite(filename, uv[..., ::-1]) + + +def flow_from_bytes(content: bytes, suffix: str = 'flo') -> ndarray: + """Read dense optical flow from bytes. + + .. note:: + This load optical flow function works for FlyingChairs, FlyingThings3D, + Sintel, FlyingChairsOcc datasets, but cannot load the data from + ChairsSDHom. + + Args: + content (bytes): Optical flow bytes got from files or other streams. + + Returns: + ndarray: Loaded optical flow with the shape (H, W, 2). + """ + + assert suffix in ('flo', 'pfm'), 'suffix of flow file must be `flo` '\ + f'or `pfm`, but got {suffix}' + + if suffix == 'flo': + return flo_from_bytes(content) + else: + return pfm_from_bytes(content) + + +def flo_from_bytes(content: bytes): + """Decode bytes based on flo file. + + Args: + content (bytes): Optical flow bytes got from files or other streams. + + Returns: + ndarray: Loaded optical flow with the shape (H, W, 2). + """ + + # header in first 4 bytes + header = content[:4] + if header != b'PIEH': + raise Exception('Flow file header does not contain PIEH') + # width in second 4 bytes + width = np.frombuffer(content[4:], np.int32, 1).squeeze() + # height in third 4 bytes + height = np.frombuffer(content[8:], np.int32, 1).squeeze() + # after first 12 bytes, all bytes are flow + flow = np.frombuffer(content[12:], np.float32, width * height * 2).reshape( + (height, width, 2)) + + return flow + + +def pfm_from_bytes(content: bytes) -> np.ndarray: + """Load the file with the suffix '.pfm'. + + Args: + content (bytes): Optical flow bytes got from files or other streams. + + Returns: + ndarray: The loaded data + """ + + file = BytesIO(content) + + color = None + width = None + height = None + scale = None + endian = None + + header = file.readline().rstrip() + if header == b'PF': + color = True + elif header == b'Pf': + color = False + else: + raise Exception('Not a PFM file.') + + dim_match = re.match(rb'^(\d+)\s(\d+)\s$', file.readline()) + if dim_match: + width, height = list(map(int, dim_match.groups())) + else: + raise Exception('Malformed PFM header.') + + scale = float(file.readline().rstrip()) + if scale < 0: # little-endian + endian = '<' + scale = -scale + else: + endian = '>' # big-endian + + data = np.frombuffer(file.read(), endian + 'f') + shape = (height, width, 3) if color else (height, width) + + data = np.reshape(data, shape) + data = np.flipud(data) + return data[:, :, :-1] + + +def read_pfm(file: str) -> np.ndarray: + """Load the file with the suffix '.pfm'. + + This function is modified from + https://lmb.informatik.uni-freiburg.de/resources/datasets/IO.py + Copyright (c) 2011, LMB, University of Freiburg. + + Args: + file (str): The file name will be loaded + + Returns: + ndarray: The loaded data + """ + file = open(file, 'rb') + + color = None + width = None + height = None + scale = None + endian = None + + header = file.readline().rstrip() + if header.decode('ascii') == 'PF': + color = True + elif header.decode('ascii') == 'Pf': + color = False + else: + raise Exception('Not a PFM file.') + + dim_match = re.match(r'^(\d+)\s(\d+)\s$', file.readline().decode('ascii')) + if dim_match: + width, height = list(map(int, dim_match.groups())) + else: + raise Exception('Malformed PFM header.') + + scale = float(file.readline().decode('ascii').rstrip()) + if scale < 0: # little-endian + endian = '<' + scale = -scale + else: + endian = '>' # big-endian + + data = np.fromfile(file, endian + 'f') + shape = (height, width, 3) if color else (height, width) + + data = np.reshape(data, shape) + data = np.flipud(data) + return data[:, :, :-1] diff --git a/MuseV/MMCM/mmcm/vision/flow/util.py b/MuseV/MMCM/mmcm/vision/flow/util.py new file mode 100755 index 0000000000000000000000000000000000000000..3dd0655bfb0b0e2ba7c07e0781fdd2db5295f222 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/flow/util.py @@ -0,0 +1,66 @@ +from typing import Callable + +import numpy as np +import torch +from torch import nn +import cv2 + + +def torch_wrap(img, flow, mode='bilinear', padding_mode='zeros', align_corners=True, outlier_func: Callable=None): + """ + reffers: + 1. https://github.com/safwankdb/ReCoNet-PyTorch/blob/master/utilities.py + 2. https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html + warp an image/tensor (img) back to output images, according to the optical flow + img: [B, C, H, W], torch.FloatTensor, [0, 1] or [0, 255] + flow: [B, 2, H, W] + return: + output: BxCxHxW + """ + B, C, H, W = img.size() + # mesh grid + xx = torch.arange(0, W).view(1,-1).repeat(H,1) + yy = torch.arange(0, H).view(-1,1).repeat(1,W) + xx = xx.view(1,1,H,W).repeat(B,1,1,1) + yy = yy.view(1,1,H,W).repeat(B,1,1,1) + grid = torch.cat((xx,yy), 1) + grid = grid.to(img.device, dtype=img.dtype) + # print(img.shape, grid.shape, flow.shape) + vgrid = grid + flow + if outlier_func is not None: + from ..utils.torch_util import find_outlier + mask = find_outlier(vgrid).to(img.device) + mask = mask.unsqueeze(dim=1).repeat(1,C,1,1) + # scale grid to [-1,1] + vgrid[:,0,:,:] = 2.0 * vgrid[:,0,:,:] / max(W - 1, 1) - 1.0 + vgrid[:,1,:,:] = 2.0 * vgrid[:,1,:,:] / max(H - 1, 1) - 1.0 + vgrid = vgrid.permute(0, 2, 3, 1) + output = nn.functional.grid_sample(img, vgrid, mode=mode, padding_mode=padding_mode, align_corners=align_corners) + if outlier_func is not None: + outlier = outlier_func(output.shape).to(img.device) + output = mask * output + (1 - mask) * outlier + output = output.to(dtype=img.dtype) + return output + + +def opencv_wrap(img:np.array, flow: np.array, outlier_func: Callable=None) -> np.array: + """wrap image with flow to output image + + Args: + img (np.array): source image, HxWx3, [0-255] + flow (np.array): flow from source image to output image, HxWx2, [-int, int] + + Returns: + np.array: output image, HxWx3, + """ + from ..utils.vision_util import find_outlier + h, w, c = flow.shape + flow[:,:,0] += np.arange(w) + flow[:,:,1] += np.arange(h)[:,np.newaxis] + output = cv2.remap(img, flow, None, cv2.INTER_LINEAR) + if outlier_func is not None: + outlier = outlier_func(output.shape) + mask = find_outlier(np.transpose(flow, (1, 2, 0))) + mask = np.repeat(mask[:, :, np.newaxis], repeats=c, axis=2) + output = mask * output + (1 - mask) * outlier + return output diff --git a/MuseV/MMCM/mmcm/vision/human/__init__.py b/MuseV/MMCM/mmcm/vision/human/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..2eae6bd85ffa14cf98812aaeeda45e221431d1d4 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/__init__.py @@ -0,0 +1,9 @@ +from .face_cluster_by_infomap.face_cluster_by_infomap import FaceClusterByInfomap +from .face_tracker import FaceTrackerByYolo5DeepSort +from .insightface_predictor import InsightfacePredictor + +__all__ = [ + "FaceClusterByInfomap", + "FaceTrackerByYolo5DeepSort", + "InsightfacePredictor", +] \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/README.md b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/README.md new file mode 100755 index 0000000000000000000000000000000000000000..12c4eca0027858bd03dbb3db406325d2220ff5d4 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/README.md @@ -0,0 +1,130 @@ +# Learning to Cluster Faces by Infomap + +## Intorduction +采用了无监督方法infomap进行人脸聚类，在公开数据集上MS-Celeb-1M、YouTube-Faces、DeepFashion获得较当前主流方法(如GCN人脸聚类等监督方法)同等或更优的效果. +通过faiss加速邻接边的构建，提高聚类速度，单批百万数据聚类仅需几分钟. 效果及性能测试详见下表. + +## Infomap Intorduction +[About Infomap](https://www.mapequation.org/publications.html#Rosvall-Axelsson-Bergstrom-2009-Map-equation) + +## About GCN Method +1. L-GCN: [Linkage-based Face Clustering via Graph Convolution Network](https://arxiv.org/abs/1903.11306), CVPR 2019 +2. GCN-D: [Learning to Cluster Faces on an Affinity Graph](https://arxiv.org/abs/1904.02749), CVPR 2019 (**Oral**) +3. GCN-V+GCN-E: [Learning to Cluster Faces via Confidence and Connectivity Estimation](https://arxiv.org/abs/2004.00445), CVPR 2020 +4. GCN+LSTM: [Density-Aware Feature Embedding for Face Clustering](https://openaccess.thecvf.com/content_CVPR_2020/papers/Guo_Density-Aware_Feature_Embedding_for_Face_Clustering_CVPR_2020_paper.pdf), CVPR 2020 +5. STAR-FC: [Structure-Aware Face Clustering on a Large-Scale Graph with 107 Nodes +](https://arxiv.org/pdf/2103.13225.pdf), CVPR 2021 [code](https://github.com/sstzal/STAR-FC) + +## Requirements +* Python >= 3.6 +* sklearn +* infomap +* numpy +* faiss-gpu(or faiss-cpu) + +## Datasets +MS-Celeb-1M : part1_test (584K)、YouTube-Faces、DeepFashion + +[data preparation](https://github.com/xiaoxiong74/face-cluster-by-infomap/tree/master/data/README.md) + +## Run +```bash +python face-cluster-by-infomap +``` + +## Results on part1_test (584K) +| Method | Precision | Recall | F-score | +| ------ |:---------:|:------:|:-------:| +| Chinese Whispers (k=80, th=0.6, iters=20) | 55.49 | 52.46 | 53.93 | +| Approx Rank Order (k=80, th=0) | 99.77 | 7.2 | 13.42 | +| MiniBatchKmeans (ncluster=5000, bs=100) | 45.48 | 80.98 | 58.25 | +| KNN DBSCAN (k=80, th=0.7, eps=0.25, min=1) | 95.25 | 52.79 | 67.93 | +| FastHAC (dist=0.72, single) | 92.07 | 57.28 | 70.63 | +| [DaskSpectral](https://ml.dask.org/clustering.html#spectral-clustering) (ncluster=8573, affinity='rbf') | 78.75 | 66.59 | 72.16 | +| [CDP](https://github.com/XiaohangZhan/cdp) (single model, th=0.7) | 80.19 | 70.47 | 75.02 | +| [L-GCN](https://github.com/yl-1993/learn-to-cluster/tree/master/lgcn) (k_at_hop=[200, 10], active_conn=10, step=0.6, maxsz=300) | 74.38 | 83.51 | 78.68 | +| GCN-D (2 prpsls) | 95.41 | 67.77 | 79.25 | +| GCN-D (5 prpsls) | 94.62 | 72.59 | 82.15 | +| GCN-D (8 prpsls) | 94.23 | 79.69 | 86.35 | +| GCN-D (20 prplss) | 94.54 | 81.62 | 87.61 | +| GCN-D + GCN-S (2 prpsls) | 99.07 | 67.22 | 80.1 | +| GCN-D + GCN-S (5 prpsls) | 98.84 | 72.01 | 83.31 | +| GCN-D + GCN-S (8 prpsls) | 97.93 | 78.98 | 87.44 | +| GCN-D + GCN-S (20 prpsls) | 97.91 | 80.86 | 88.57 | +| GCN-V | 92.45 | 82.42 | 87.14 | +| GCN-V + GCN-E | 92.56 | 83.74 | 87.93 | +| Infomap(ours)(k=50,min_sim=0.58) | 95.50 | 92.51 | 93.98 | + +![](image/evaluate.png) + +## Results on YouTube-Faces + +| Method | Pairwise F-score | BCubed F-score | NMI | +| ------ |:---------:|:------:|:-------:| +| Chinese Whispers (k=160, th=0.75, iters=20) | 72.9 | 70.55 | 93.25 | +| Approx Rank Order (k=200, th=0) | 76.45 | 75.45 | 94.34 | +| Kmeans (ncluster=1436) | 67.86 | 75.77 | 93.99 | +| KNN DBSCAN (k=160, th=0., eps=0.3, min=1) | 91.35 | 89.34 | 97.52 | +| FastHAC (dist=0.72, single) | 93.07 | 87.98 | 97.19 | +| GCN-D (4 prpsls) | 94.44 | 91.33 | 97.97 | +| Infomap(ours)(k=400,min_sim=0.56) | 92.82 | 91.78 | 98.04 | + + + +## Results on DeepFashion + +| Method | Pairwise F-score | BCubed F-score | NMI | +| ------ |:---------:|:------:|:-------:| +| Chinese Whispers (k=5, th=0.7, iters=20) | 31.22 | 53.25 | 89.8 | +| Approx Rank Order (k=10, th=0) | 25.04 | 52.77 | 88.71 | +| Kmeans (ncluster=3991) | 32.02 | 53.3 | 88.91 | +| KNN DBSCAN (k=4, th=0., eps=0.1, min=2) | 25.07 | 53.23 | 90.75 | +| FastHAC (dist=0.4, single) | 22.54 | 48.77 | 90.44 | +| Meanshift (bandwidth=0.5) | 31.61 | 56.73 | 89.29 | +| Spectral (ncluster=3991, affinity='rbf') | 29.6 | 47.12 | 86.95 | +| DaskSpectral (ncluster=3991, affinity='rbf') | 24.25 | 44.11 | 86.21 | +| CDP (single model, k=2, th=0.5, maxsz=200) | 28.28 | 57.83 | 90.93 | +| L-GCN (k_at_hop=[5, 5], active_conn=5, step=0.5, maxsz=50) | 30.7 | 60.13 | 90.67 | +| GCN-D (2 prpsls) | 29.14 | 59.09 | 89.48 | +| GCN-D (8 prpsls) | 32.52 | 57.52 | 89.54 | +| GCN-D (20 prpsls) | 33.25 | 56.83 | 89.36 | +| GCN-V | 33.59 | 59.41 | 90.88 | +| GCN-V + GCN-E | 38.47 | 60.06 | 90.5 | +| Infomap(ours)(k=400,min_sim=0.88) | 38.67 | 60.48 | 90.97 | + + +## Time Consumes and Gpu Memory (k=50,min_sim=0.58) +| Nodes | Edges | TimeCount | Gpu Memory | +| ------ |:---------:|:---------:|:---------:| +| 500000 | 16535263 | 160(s) | 2745(MiB) | +| 1000000 | 30206572 | 400(s) | 3235(MiB) | + +## Comments +* k值越大，TimeCount会变长，Gpu Memory会增加 +* k值并非infomap的参数，仅为faiss构建knn构建时使用 +* 数据量增加一倍，KNN构建时间为原来的4倍(实质为n*n的向量搜索) + +## Feature Extraction +To experiment with your own face pictures, it is required to extracted face features from the pictures. + +For training face recognition and feature extraction, you may use any frameworks below, including but not limited to: + +[https://github.com/yl-1993/hfsoftmax](https://github.com/yl-1993/hfsoftmax) + +[https://github.com/XiaohangZhan/face_recognition_framework](https://github.com/XiaohangZhan/face_recognition_framework) + + +## References +* [最小熵原理（五）：“层层递进”之社区发现与聚类](https://spaces.ac.cn/archives/7006) +* [人脸聚类主流方案](https://github.com/yl-1993/learn-to-cluster) + +## Citation + +``` +@misc{face-cluster-by-infomap, + title={face-cluster-by-infomap}, + author={Yongfu Xiong}, + year={2020}, + howpublished={\url{https://github.com/xiaoxiong74/face-cluster-by-infomap}}, +} +``` diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/__init__.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/data/README.md b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/data/README.md new file mode 100755 index 0000000000000000000000000000000000000000..2f152d734150714b0bd27b18e0c0f0558eafae01 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/data/README.md @@ -0,0 +1,29 @@ +## Datasets +MS-Celeb-1M part1_test(584K)、YouTube-Faces、DeepFashion + +[download data BaiduYun](https://pan.baidu.com/s/1cElauIJjDIM8QRgntFLB6g)(passwd: v06l) + +### Data format +The data directory is constucted as follows: +``` +. +├── data +| ├── features +| | └── xxx.bin +│ ├── labels +| | └── xxx.meta + +- `features` currently supports binary file. +- `labels` supports plain text where each line indicates a label corresponding to the feature file. + +``` + +### Feature Extraction +To experiment with your own face pictures, it is required to extracted face features from the pictures. + +For training face recognition and feature extraction, you may use any frameworks below, including but not limited to: + +[https://github.com/yl-1993/hfsoftmax](https://github.com/yl-1993/hfsoftmax) + +[https://github.com/XiaohangZhan/face_recognition_framework](https://github.com/XiaohangZhan/face_recognition_framework) + diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/__init__.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..ade393198c6f736d5f7930e278fde4a64896161d --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/__init__.py @@ -0,0 +1,5 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +from .metrics import * +from .evaluate import evaluate diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/evaluate.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/evaluate.py new file mode 100755 index 0000000000000000000000000000000000000000..d4921a85fc63ecc3a06b368778bd5347de163a7c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/evaluate.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import inspect +import argparse +import numpy as np + +from ..evaluation import metrics +from ..utils import Timer, TextColors + + +def _read_meta(fn): + labels = list() + lb_set = set() + with open(fn) as f: + for lb in f.readlines(): + lb = int(lb.strip()) + labels.append(lb) + lb_set.add(lb) + return np.array(labels), lb_set + + +def evaluate(gt_labels, pred_labels, metric='pairwise'): + if isinstance(gt_labels, str) and isinstance(pred_labels, str): + print('[gt_labels] {}'.format(gt_labels)) + print('[pred_labels] {}'.format(pred_labels)) + gt_labels, gt_lb_set = _read_meta(gt_labels) + pred_labels, pred_lb_set = _read_meta(pred_labels) + + print('#inst: gt({}) vs pred({})'.format(len(gt_labels), + len(pred_labels))) + print('#cls: gt({}) vs pred({})'.format(len(gt_lb_set), + len(pred_lb_set))) + + metric_func = metrics.__dict__[metric] + + with Timer('evaluate with {}{}{}'.format(TextColors.FATAL, metric, + TextColors.ENDC)): + result = metric_func(gt_labels, pred_labels) + if isinstance(result, np.float): + print('{}{}: {:.4f}{}'.format(TextColors.OKGREEN, metric, result, + TextColors.ENDC)) + else: + ave_pre, ave_rec, fscore = result + print('{}ave_pre: {:.4f}, ave_rec: {:.4f}, fscore: {:.4f}{}'.format( + TextColors.OKGREEN, ave_pre, ave_rec, fscore, TextColors.ENDC)) + + +if __name__ == '__main__': + metric_funcs = inspect.getmembers(metrics, inspect.isfunction) + metric_names = [n for n, _ in metric_funcs] + + parser = argparse.ArgumentParser(description='Evaluate Cluster') + parser.add_argument('--gt_labels', type=str, required=True) + parser.add_argument('--pred_labels', type=str, required=True) + parser.add_argument('--metric', default='pairwise', choices=metric_names) + args = parser.parse_args() + + evaluate(args.gt_labels, args.pred_labels, args.metric) diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/metrics.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/metrics.py new file mode 100755 index 0000000000000000000000000000000000000000..e3855fbb3229f56a386913d742701133072a6a08 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/evaluation/metrics.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +from __future__ import division + +import numpy as np +import json +from sklearn.metrics.cluster import (contingency_matrix, + normalized_mutual_info_score) +from sklearn.metrics import (precision_score, recall_score) + +__all__ = ['pairwise', 'bcubed', 'nmi', 'precision', 'recall', 'accuracy'] + + +class NpEncoder(json.JSONEncoder): + def default(self, obj): + if isinstance(obj, np.integer): + return int(obj) + elif isinstance(obj, np.floating): + return float(obj) + elif isinstance(obj, np.ndarray): + return obj.tolist() + else: + return super(NpEncoder, self).default(obj) + + +def _check(gt_labels, pred_labels): + if gt_labels.ndim != 1: + raise ValueError("gt_labels must be 1D: shape is %r" % + (gt_labels.shape,)) + if pred_labels.ndim != 1: + raise ValueError("pred_labels must be 1D: shape is %r" % + (pred_labels.shape,)) + if gt_labels.shape != pred_labels.shape: + raise ValueError( + "gt_labels and pred_labels must have same size, got %d and %d" % + (gt_labels.shape[0], pred_labels.shape[0])) + return gt_labels, pred_labels + + +def _get_lb2idxs(labels): + lb2idxs = {} + for idx, lb in enumerate(labels): + if lb not in lb2idxs: + lb2idxs[lb] = [] + lb2idxs[lb].append(idx) + return lb2idxs + + +def _compute_fscore(pre, rec): + return 2. * pre * rec / (pre + rec) + + +def fowlkes_mallows_score(gt_labels, pred_labels, sparse=True): + ''' The original function is from `sklearn.metrics.fowlkes_mallows_score`. + We output the pairwise precision, pairwise recall and F-measure, + instead of calculating the geometry mean of precision and recall. + ''' + n_samples, = gt_labels.shape + + c = contingency_matrix(gt_labels, pred_labels, sparse=sparse) + tk = np.dot(c.data, c.data) - n_samples + pk = np.sum(np.asarray(c.sum(axis=0)).ravel() ** 2) - n_samples + qk = np.sum(np.asarray(c.sum(axis=1)).ravel() ** 2) - n_samples + + avg_pre = tk / pk + avg_rec = tk / qk + fscore = _compute_fscore(avg_pre, avg_rec) + + return avg_pre, avg_rec, fscore + + +def pairwise(gt_labels, pred_labels, sparse=True): + _check(gt_labels, pred_labels) + return fowlkes_mallows_score(gt_labels, pred_labels, sparse) + + +def bcubed0(gt_labels, pred_labels): + """ + 计算bcubed的precision, recall, f-score及expanding + :param gt_labels: + :param pred_labels: + :return: + """ + gt_lb2idxs = _get_lb2idxs(gt_labels) + pred_lb2idxs = _get_lb2idxs(pred_labels) + + num_lbs = len(gt_lb2idxs) + pre = np.zeros(num_lbs) + rec = np.zeros(num_lbs) + gt_num = np.zeros(num_lbs) + + expand = np.zeros(num_lbs) + for i, gt_idxs in enumerate(gt_lb2idxs.values()): + all_pred_lbs = np.unique(pred_labels[gt_idxs]) + gt_num[i] = len(gt_idxs) + expand[i] = all_pred_lbs.shape[0] + for pred_lb in all_pred_lbs: + pred_idxs = pred_lb2idxs[pred_lb] + n = 1. * np.intersect1d(gt_idxs, pred_idxs).size + pre[i] += n ** 2 / len(pred_idxs) + rec[i] += n ** 2 / gt_num[i] + + gt_num = gt_num.sum() + avg_pre = pre.sum() / gt_num + avg_rec = rec.sum() / gt_num + fscore = _compute_fscore(avg_pre, avg_rec) + + return avg_pre, avg_rec, fscore, expand.mean() + + +def bcubed(gt_labels, pred_labels): + """ + 输出becubed函数中各项指标，以及丢弃n个档案后的指标 + 和剩余的图片数量和label数量 + :param gt_labels: + :param pred_labels: + :param n: + :return: + """ + pred_lb2idxs = _get_lb2idxs(pred_labels) + n = 1 + ind = [] + for i in pred_lb2idxs.values(): + if len(i) > n: + for m in i: + ind.append(m) + + avg_pre, avg_rec, fscore, expand = bcubed0(gt_labels, pred_labels) + # print('avg_pre:{}, avg_rec:{}, fscore:{}, expanding:{}, rest images:{}, rest_gt_labels:{} '. + # format(avg_pre, avg_rec, fscore, expand, len(gt_labels), len(list(set(gt_labels))))) + # + # avg_pre1, avg_rec1, fscore1, expand1 = bcubed0(gt_labels[ind], pred_labels[ind]) + # print('avg_pre:{}, avg_rec:{}, fscore:{}, expanding:{}, rest images:{}, rest_gt_labels:{} '. + # format(avg_pre1, avg_rec1, fscore1, expand1, len(ind), len(list(set(gt_labels[ind]))))) + + return avg_pre, avg_rec, fscore + + +def nmi(gt_labels, pred_labels): + return normalized_mutual_info_score(pred_labels, gt_labels) + + +def precision(gt_labels, pred_labels): + return precision_score(gt_labels, pred_labels) + + +def recall(gt_labels, pred_labels): + return recall_score(gt_labels, pred_labels) + + +def accuracy(gt_labels, pred_labels): + return np.mean(gt_labels == pred_labels) diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/face_cluster_by_infomap.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/face_cluster_by_infomap.py new file mode 100755 index 0000000000000000000000000000000000000000..dee3d8b92f79330d5addbc8982537df6ec02d8f8 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/face_cluster_by_infomap.py @@ -0,0 +1,692 @@ +# -*- coding: UTF-8 -*- +from typing import Dict +import time +from multiprocessing.dummy import Pool as Threadpool +from multiprocessing import Pool +import multiprocessing as mp +import os +import json +from collections import Counter +import argparse +import traceback +import random + +from tqdm import tqdm +import numpy as np + +from .utils import Timer +from .evaluation import evaluate, accuracy +from ..roles import load_roles + +def l2norm(vec): + """ + 归一化 + :param vec: + :return: + """ + vec /= np.linalg.norm(vec, axis=1).reshape(-1, 1) + return vec + + +def cosine_distance(a, b, data_is_normalized=False): + """Compute pair-wise cosine distance between points in `a` and `b`. + Parameters + ---------- + a : array_like + An NxM matrix of N samples of dimensionality M. + b : array_like + An LxM matrix of L samples of dimensionality M. + data_is_normalized : Optional[bool] + If True, assumes rows in a and b are unit length vectors. + Otherwise, a and b are explicitly normalized to lenght 1. + Returns + ------- + ndarray + Returns a matrix of size len(a), len(b) such that eleement (i, j) + contains the squared distance between `a[i]` and `b[j]`. + """ + if not data_is_normalized: + a = np.asarray(a) / np.linalg.norm(a, axis=1, keepdims=True) + b = np.asarray(b) / np.linalg.norm(b, axis=1, keepdims=True) + return 1.0 - np.dot(a, b.T) + + +def intdict2ndarray(d, default_val=-1): + arr = np.zeros(len(d)) + default_val + for k, v in d.items(): + arr[k] = v + return arr + + +def read_meta(fn_meta, start_pos=0, verbose=True): + """ + idx2lb：每一个顶点对应一个类 + lb2idxs：每个类对应一个id + """ + lb2idxs = {} + idx2lb = {} + with open(fn_meta) as f: + for idx, x in enumerate(f.readlines()[start_pos:]): + lb = int(x.strip()) + if lb not in lb2idxs: + lb2idxs[lb] = [] + lb2idxs[lb] += [idx] + idx2lb[idx] = lb + + inst_num = len(idx2lb) + cls_num = len(lb2idxs) + if verbose: + print("[{}] #cls: {}, #inst: {}".format(fn_meta, cls_num, inst_num)) + return lb2idxs, idx2lb + + +class knn: + def __init__(self, feats, k, index_path="", verbose=True): + pass + + def filter_by_th(self, i): + th_nbrs = [] + th_dists = [] + nbrs, dists = self.knns[i] + for n, dist in zip(nbrs, dists): + if 1 - dist < self.th: + continue + th_nbrs.append(n) + th_dists.append(dist) + th_nbrs = np.array(th_nbrs) + th_dists = np.array(th_dists) + return th_nbrs, th_dists + + def get_knns(self, th=None): + if th is None or th <= 0.0: + return self.knns + # TODO: optimize the filtering process by numpy + # nproc = mp.cpu_count() + nproc = 1 + with Timer("filter edges by th {} (CPU={})".format(th, nproc), self.verbose): + self.th = th + self.th_knns = [] + tot = len(self.knns) + if nproc > 1: + pool = mp.Pool(nproc) + th_knns = list( + tqdm(pool.imap(self.filter_by_th, range(tot)), total=tot) + ) + pool.close() + else: + th_knns = [self.filter_by_th(i) for i in range(tot)] + return th_knns + + +class knn_faiss(knn): + """ + 内积暴力循环 + 归一化特征的内积等价于余弦相似度 + """ + + def __init__(self, feats, k, index_path="", knn_method="faiss-cpu", verbose=True): + import faiss + + with Timer("[{}] build index {}".format(knn_method, k), verbose): + knn_ofn = index_path + ".npz" + if os.path.exists(knn_ofn): + print("[{}] read knns from {}".format(knn_method, knn_ofn)) + self.knns = np.load(knn_ofn)["data"] + else: + feats = feats.astype("float32") + size, dim = feats.shape + if knn_method == "faiss-gpu": + import math + + i = math.ceil(size / 1000000) + if i > 1: + i = (i - 1) * 4 + res = faiss.StandardGpuResources() + res.setTempMemory(i * 1024 * 1024 * 1024) + index = faiss.GpuIndexFlatIP(res, dim) + else: + index = faiss.IndexFlatIP(dim) + index.add(feats) + with Timer("[{}] query topk {}".format(knn_method, k), verbose): + knn_ofn = index_path + ".npz" + if os.path.exists(knn_ofn): + pass + else: + sims, nbrs = index.search(feats, k=k) + # torch.cuda.empty_cache() + self.knns = [ + (np.array(nbr, dtype=np.int32), 1 - np.array(sim, dtype=np.float32)) + for nbr, sim in zip(nbrs, sims) + ] + + +def knns2ordered_nbrs(knns, sort=True): + if isinstance(knns, list): + knns = np.array(knns) + nbrs = knns[:, 0, :].astype(np.int32) + dists = knns[:, 1, :] + if sort: + # sort dists from low to high + nb_idx = np.argsort(dists, axis=1) + idxs = np.arange(nb_idx.shape[0]).reshape(-1, 1) + dists = dists[idxs, nb_idx] + nbrs = nbrs[idxs, nb_idx] + return dists, nbrs + + +# 构造边 +def get_links(single, links, nbrs, dists, frame_idx, trackids, det_scores): + for i in tqdm(range(nbrs.shape[0])): + count = 0 + for j in range(0, len(nbrs[i])): + # 排除本身节点 + if i == nbrs[i][j]: + continue + elif dists[i][j] > 1 - min_sim: + break + elif (nbrs[i][j], i) in links.keys(): + count += 1 + continue + elif frame_idx[i][0] == frame_idx[nbrs[i][j]][0]: + # links[(i, nbrs[i][j])] = -np.inf + # count += 1 + continue + elif det_scores[i] * det_scores[nbrs[i][j]] < 0.55: + continue + else: + count += 1 + links[(i, nbrs[i][j])] = float(1 - dists[i][j]) + # links[(i, nbrs[i][j])] = det_scores[i] * det_scores[nbrs[i][j]] * float(1 - dists[i][j]) + # links[(i, nbrs[i][j])] = (1 if genders[i]==genders[nbrs[i][j]] else 0.8)*det_scores[i]*det_scores[nbrs[i][j]]*float(1 - dists[i][j]) + + track_weight = 10 + if trackids[i] != "-1": + trackids = np.array(trackids, dtype=np.int) + same_trackid_idx = np.where(trackids == trackids[i])[0] + for j in same_trackid_idx: + if i != j: + if (j, i) in links.keys(): + links[(j, i)] = track_weight + elif (i, j) in links.keys(): + links[(i, j)] = track_weight + else: + links[(i, j)] = track_weight + count += 1 + + # 统计孤立点 + if count == 0: + single.append(i) + return single, links + + +# 构造边 +def get_links_directed(single, links, nbrs, dists, frame_idx, trackids, det_scores): + for i in tqdm(range(nbrs.shape[0])): + count = 0 + for j in range(0, len(nbrs[i])): + # 排除本身节点 + if i == nbrs[i][j]: + continue + elif dists[i][j] > 1 - min_sim: + break + elif frame_idx[i][0] == frame_idx[nbrs[i][j]][0]: + # links[(i, nbrs[i][j])] = -np.inf + # count += 1 + continue + elif det_scores[i] * det_scores[nbrs[i][j]] < 0.55: + continue + else: + count += 1 + links[(i, nbrs[i][j])] = float(1 - dists[i][j]) + # links[(i, nbrs[i][j])] = det_scores[i] * det_scores[nbrs[i][j]] * float(1 - dists[i][j]) + # links[(i, nbrs[i][j])] = (1 if genders[i]==genders[nbrs[i][j]] else 0.8)*det_scores[i]*det_scores[nbrs[i][j]]*float(1 - dists[i][j]) + + track_weight = 2 + if trackids[i] != "-1": + trackids = np.array(trackids, dtype=np.int) + same_trackid_idx = np.where(trackids == trackids[i])[0] + for j in same_trackid_idx: + if i != j: + if (i, j) in links.keys(): + links[(i, j)] = track_weight + else: + links[(i, j)] = track_weight + count += 1 + + # 统计孤立点 + if count == 0: + single.append(i) + return single, links + + +def cluster_by_infomap( + nbrs, dists, pred_label_path, frame_idx, trackids, det_scores, save_result=False +): + """ + 基于infomap的聚类 + :param nbrs: + :param dists: + :param pred_label_path: + :return: + """ + import infomap + single = [] + links = {} + with Timer("get links", verbose=True): + single, links = get_links_directed( + single=single, + links=links, + nbrs=nbrs, + dists=dists, + frame_idx=frame_idx, + det_scores=det_scores, + trackids=trackids, + ) + print("pair数量：{}".format(len(links.keys()))) + + infomapWrapper = infomap.Infomap("--two-level --directed") + for (i, j), sim in tqdm(links.items()): + _ = infomapWrapper.addLink(int(i), int(j), sim) + + # 聚类运算 + infomapWrapper.run() + + label2idx = {} + idx2label = {} + + # 聚类结果统计 + for node in infomapWrapper.iterTree(): + # node.physicalId 特征向量的编号 + # node.moduleIndex() 聚类的编号 + idx2label[node.physicalId] = node.moduleIndex() + if node.moduleIndex() not in label2idx: + label2idx[node.moduleIndex()] = [] + label2idx[node.moduleIndex()].append(node.physicalId) + + node_count = 0 + for k, v in label2idx.items(): + if k == 0: + node_count += len(v[2:]) + label2idx[k] = v[2:] + # print(k, v[2:]) + else: + node_count += len(v[1:]) + label2idx[k] = v[1:] + # print(k, v[1:]) + + for i in range(nbrs.shape[0]): + if (i not in idx2label.keys()) and (i not in single): + single.append(i) + # 孤立点个数 + print("孤立点数：{}".format(len(single))) + + keys_len = len(list(label2idx.keys())) + # print(keys_len) + + # 孤立点放入到结果中 + for single_node in single: + if single_node not in idx2label.keys(): + idx2label[single_node] = keys_len + label2idx[keys_len] = [single_node] + keys_len += 1 + + print("总类别数：{}".format(keys_len)) + + idx_len = len(list(idx2label.keys())) + print("总节点数：{}".format(idx_len)) + + # 保存结果 + if save_result: + with open(pred_label_path, "w") as of: + for idx in range(idx_len): + of.write(str(idx2label[idx]) + "\n") + + if label_path is not None: + pred_labels = intdict2ndarray(idx2label) + true_lb2idxs, true_idx2lb = read_meta(label_path) + gt_labels = intdict2ndarray(true_idx2lb) + for metric in metrics: + evaluate(gt_labels, pred_labels, metric) + + return idx2label, label2idx + + +def get_dist_nbr(features, k=80, knn_method="faiss-cpu"): + features = l2norm(features) + + index = knn_faiss(feats=features, k=k, knn_method=knn_method) + knns = index.get_knns() + dists, nbrs = knns2ordered_nbrs(knns) + return dists, nbrs + + +def detection_dic_to_list(face_detections): + features = [] + frame_idx = [] + trackids = [] + det_scores = [] + genders = [] + track2idx = {} + for i in range(len(face_detections)): + if face_detections[i]["faces"]: + for j in range(len(face_detections[i]["faces"])): + features.append(face_detections[i]["faces"][j]["embedding"]) + frame_idx.append([i, j]) + det_scores.append(float(face_detections[i]["faces"][j]["det_score"])) + genders.append(face_detections[i]["faces"][j]["gender"]) + try: + c_trackid = int(face_detections[i]["faces"][j]["trackid"]) + except: + c_trackid = -1 + print( + "no trackid", + face_detections[i]["frame_idx"], + face_detections[i]["faces"][j]["bbox"], + ) + trackids.append(c_trackid) + if c_trackid in track2idx.keys(): + track2idx[c_trackid].append(len(features) - 1) + else: + track2idx[c_trackid] = [len(features) - 1] + + return features, frame_idx, trackids, det_scores, genders, track2idx + + +def top_role(label2frame, idx2label, frameids, face_detections, max_id_num=20): + """ + 统计出镜率前max_id_num位的角色id + :param label2frame: + :param idx2label: + :param max_id_num: + :return: + """ + len_list = list(map(len, list(map(set, list(label2frame.values()))))) + sort_idx = np.argsort(len_list) + sort_idx = sort_idx[::-1] + id_sort = np.array(list(label2frame.keys()))[sort_idx].tolist() + top_id = id_sort[:max_id_num] + print(top_id) + top_id_info = {} + for i in range(len(idx2label)): + current_id = idx2label[i] + if current_id in top_id: + current_face = face_detections[frameids[i][0]]["faces"][frameids[i][1]] + current_gender = float(current_face["gender"]) + current_det_score = float(current_face["det_score"]) + current_age = int(current_face["age"]) + current_frame = int(face_detections[frameids[i][0]]["frame_idx"]) + current_embedding = current_face["embedding"] + if current_id in top_id_info.keys(): + top_id_info[current_id]["gender"].append(current_gender) + top_id_info[current_id]["det_score"].append(current_det_score) + top_id_info[current_id]["age"].append(current_age) + top_id_info[current_id]["embedding"].append(current_embedding) + top_id_info[current_id]["frame"].append(current_frame) + else: + top_id_info[current_id] = { + "gender": [current_gender], + "det_score": [current_det_score], + "age": [current_age], + "embedding": [current_embedding], + "frame": [current_frame], + } + + leading_roles = [] + for i in top_id: + current_gender_f = np.mean(top_id_info[i]["gender"]) + current_gender = "M" if current_gender_f > 0 else "F" + current_age = int(np.round(np.mean(top_id_info[i]["age"]))) + info = { + "name": "", + "age": current_age, + "gender": current_gender, + "gender_confidence": round(current_gender_f, 3), + "appearance_frequency": round( + len(set(top_id_info[i]["frame"])) / len(face_detections), 3 + ), + "roleid": top_id.index(i), + "faceid": i, + "embedding": random.sample( + top_id_info[i]["embedding"], min(100, len(top_id_info[i]["embedding"])) + ), + "det_score_average": np.mean(top_id_info[i]["det_score"]), + "det_score_max": np.max(top_id_info[i]["det_score"]), + } + leading_roles.append(info) + return leading_roles, id_sort + + +def role2name(leading_roles, face_name_dataset, face_distance_threshold=0.75): + for info in leading_roles: + min_distance = np.inf + name = "" + for key, value in face_name_dataset.items(): + distance = cosine_distance( + np.array(info["embedding"]), np.array(value) + ).mean() + if distance < min_distance and distance < face_distance_threshold: + min_distance = distance + name = key + info["name"] = name + if name: + print(info["roleid"], name) + return leading_roles + + +knn_method = "faiss-gpu" +metrics = ["pairwise", "bcubed", "nmi"] +min_sim = 0.4 +k = 2048 +# true_label +label_path = None + + +def predict(source_path, video_map, face_name_dataset, max_id_num=20): + video_detect = video_map + try: + face_detections = video_detect["face_detections"] + except: + face_detections = video_detect["face_detections"] + ( + features, + frameids, + trackids, + det_scores, + genders, + track2idx, + ) = detection_dic_to_list(face_detections) + + # 每个track挑选最多5个人脸进行聚类 + select_idx = [] + max_num_per_track = 5 + for key, value in track2idx.items(): + if key == -1 or len(value) <= max_num_per_track: + select_idx.extend(value) + else: + duration = len(value) // max_num_per_track + select_idx.extend(value[::duration]) + select_idx = list(set(select_idx)) + select_idx.sort() + select_idx = np.array(select_idx) + select_features = np.array(features, np.float32)[select_idx] + select_trackids = np.array(trackids, dtype=np.int)[select_idx] + select_det_scores = np.array(det_scores, np.float32)[select_idx] + select_frameids = np.array(frameids, np.int)[select_idx] + pred_label_path = "./part1_test_predict.txt" + + # 将挑选出来的人脸进行聚类 + with Timer("All face cluster step"): + dists, nbrs = get_dist_nbr( + features=select_features, k=k, knn_method=knn_method + ) + print(dists.shape, nbrs.shape) + part_idx2label, part_label2idx = cluster_by_infomap( + nbrs, + dists, + pred_label_path, + select_frameids, + select_trackids, + select_det_scores, + save_result=False, + ) + + # 将聚类结果对应到所有人脸 + idx2label = {} + label2idx = {} + label2frame = {} + for i in range(len(select_idx)): + o_i = select_idx[i] + label = part_idx2label[i] + idx2label[o_i] = part_idx2label[i] + if label in label2idx.keys(): + label2idx[label].append(o_i) + label2frame[label].append(frameids[o_i][0]) + else: + label2idx[label] = [o_i] + label2frame[label] = [frameids[o_i][0]] + for i in range(len(features)): + if i not in idx2label.keys(): + c_labels = [] + c_trackid = trackids[i] + same_trackid_idx = track2idx[c_trackid] + same_trackid_idx.remove(i) + for j in same_trackid_idx: + if (i != j) and (j in idx2label.keys()): + c_labels.append(idx2label[j]) + if len(c_labels) > 0: + label = Counter(c_labels).most_common()[0][0] + else: + label = len(list(label2idx.keys())) + idx2label[i] = label + if label in label2idx.keys(): + label2idx[label].append(i) + label2frame[label].append(frameids[i][0]) + else: + label2idx[label] = [i] + label2frame[label] = [frameids[i][0]] + + leading_roles, id_sort = top_role( + label2frame, idx2label, frameids, face_detections, max_id_num=20 + ) + + video_detect["role_info"] = { + "role_num": len(label2frame), + "leading_roles": leading_roles, + } + + # 给每个detection分配faceid和roleid + assert len(features) == len(list(idx2label.keys())) + for i in range(len(features)): + label = idx2label[i] + face_detections[frameids[i][0]]["faces"][frameids[i][1]]["faceid"] = label + face_detections[frameids[i][0]]["faces"][frameids[i][1]][ + "roleid" + ] = id_sort.index(label) + + video_detect["role_info"]["leading_roles"] = role2name( + video_detect["role_info"]["leading_roles"], face_name_dataset + ) + + save_dir = os.path.dirname(save_path) + if not os.path.exists(save_dir): + os.makedirs(save_dir) + with open(save_path, "w", encoding="utf-8") as fp: + json.dump(video_detect, fp, ensure_ascii=False, indent=4) + + # 将人脸聚类信息整合进video_map + video_map = json.load(open(map_path, encoding="UTF-8")) + if "single_frame_transiton_score" in video_map: + del video_map["single_frame_transiton_score"] + if "all_frame_transiton_score" in video_map: + del video_map["all_frame_transiton_score"] + video_map["role_info"] = video_detect["role_info"] + video_map["face_num_per_frame"] = sum( + [len(i["faces"]) if i["faces"] else 0 for i in face_detections] + ) / len(face_detections) + # video_map["role_num_per_frame"] = sum(len_list) / len(face_detections) + + face_idx = 0 + truncate_time = 0.1 + truncate_frame = int(video_map["sample_fps"] * truncate_time) + for slice in video_map["clips"]: + frame_start = slice["frame_start"] + frame_end = slice["frame_end"] + if (slice["cliptype"] == "body") and ( + frame_end - frame_start + 1 > 2 * truncate_frame + ): + frame_start += truncate_frame + frame_end -= truncate_frame + frame_num = 0 + face_num = 0 + roles = {} + + while face_idx < len(face_detections) and ( + face_detections[face_idx]["frame_idx"] < frame_start + ): + face_idx += 1 + + while face_idx < len(face_detections) and ( + frame_start <= face_detections[face_idx]["frame_idx"] <= frame_end + ): + if face_detections[face_idx]["faces"]: + for face in face_detections[face_idx]["faces"]: + c_roleid = face["roleid"] + if (c_roleid is not None) and (c_roleid < 1000): + if c_roleid in roles: + if ( + face_detections[face_idx]["frame_idx"] + in roles[c_roleid]["bbox"] + ): + roles[c_roleid]["bbox"][ + face_detections[face_idx]["frame_idx"] + ].append(face["bbox"]) + else: + roles[c_roleid]["bbox"][ + face_detections[face_idx]["frame_idx"] + ] = [face["bbox"]] + else: + roles[c_roleid] = { + "bbox": { + face_detections[face_idx]["frame_idx"]: [ + face["bbox"] + ] + }, + "name": video_detect["role_info"]["leading_roles"][ + c_roleid + ]["name"] + if c_roleid + < len(video_detect["role_info"]["leading_roles"]) + else "", + } + face_num += len(face_detections[face_idx]["faces"]) + face_idx += 1 + frame_num += 1 + slice["roles"] = roles + slice["face_num_per_frame"] = (face_num / frame_num) if frame_num > 0 else None + slice["role_num_per_frame"] = ( + (len(roles) / frame_num) if frame_num > 0 else None + ) + if "feat" in slice: + del slice["feat"] + return video_map + + +class FaceClusterByInfomap(object): + def __init__( + self, + roles_path, + ): + self.roles_dataset = load_roles(roles_path) + + def __call__( + self, + source_path, + video_map, + ): + video_map = predict( + source_path, + video_map, + self.roles_dataset, + max_id_num=20, + ) + return video_map diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/requirements.txt b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/requirements.txt new file mode 100755 index 0000000000000000000000000000000000000000..4048ce9f9663870a68c017787f30a22d805f96f9 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/requirements.txt @@ -0,0 +1,6 @@ +tqdm +numpy>=1.18.1 +scipy +sklearn +infomap +faiss-gpu \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/utils.py b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/utils.py new file mode 100755 index 0000000000000000000000000000000000000000..7fd460db63a10b7069d432d73f1078d7cd0ad26a --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_cluster_by_infomap/utils.py @@ -0,0 +1,29 @@ +import time + + +class TextColors: + HEADER = '\033[35m' + OKBLUE = '\033[34m' + OKGREEN = '\033[32m' + WARNING = '\033[33m' + FATAL = '\033[31m' + ENDC = '\033[0m' + BOLD = '\033[1m' + UNDERLINE = '\033[4m' + + +class Timer(): + def __init__(self, name='task', verbose=True): + self.name = name + self.verbose = verbose + + def __enter__(self): + self.start = time.time() + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + if self.verbose: + print('[Time] {} consumes {:.4f} s'.format( + self.name, + time.time() - self.start)) + return exc_type is None \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/human/face_tracker.py b/MuseV/MMCM/mmcm/vision/human/face_tracker.py new file mode 100755 index 0000000000000000000000000000000000000000..51cdf0fe418522cdd0a493d21f2cb3efa0d3cc17 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/face_tracker.py @@ -0,0 +1,241 @@ +# limit the number of cpus used by high performance libraries +import os +from typing import Dict + +os.environ["OMP_NUM_THREADS"] = "1" +os.environ["OPENBLAS_NUM_THREADS"] = "1" +os.environ["MKL_NUM_THREADS"] = "1" +os.environ["VECLIB_MAXIMUM_THREADS"] = "1" +os.environ["NUMEXPR_NUM_THREADS"] = "1" +import sys +import argparse +import os +from pathlib import Path +import json +import traceback + +import numpy as np +import torch + + +FILE = Path(__file__).resolve() +ROOT = FILE.parents[0] # yolov5 deepsort root directory +if str(ROOT) not in sys.path: + sys.path.append(str(ROOT)) # add ROOT to PATH +ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative + + +def detect(tracker, device, source_path, video_map, opt): + ( + out, + show_vid, + save_vid, + save_txt, + imgsz, + evaluate, + half, + project, + exist_ok, + update, + save_crop, + ) = ( + opt.output, + opt.show_vid, + opt.save_vid, + opt.save_txt, + opt.imgsz, + opt.evaluate, + opt.half, + opt.project, + opt.exist_ok, + opt.update, + opt.save_crop, + ) + from yolov5.utils.general import xyxy2xywh + from yolov5.utils.torch_utils import select_device + # Initialize + device = select_device(device) + half &= device.type != "cpu" # half precision only supported on CUDA + # initialize deepsort + + try: + transition_data = video_map["clips"] + except: + print("no transition_data") + transition_data = None + try: + c_box = video_map["content_box"] + except: + print("no content_box") + c_box = None + + video_detect = json.load(open(source_path, encoding="UTF-8")) + face_detections = video_detect["face_detections"] + + slice_id = 0 + for detects in face_detections: + frame_idx = detects["frame_idx"] + + while ( + transition_data + and (slice_id < len(transition_data)) + and (frame_idx >= transition_data[slice_id]["frame_end"]) + ): + # print(frame_idx, transition_data[slice_id]['frame_end']) + tracker.tracker.tracks = [] + slice_id += 1 + + pred = detects["faces"] + if pred is not None and len(pred): + # Rescale boxes from img_size to im0 size + det = [] + confs = [] + clss = [] + features = [] + for p in pred: + det.append(p["bbox"]) + confs.append(float(p["det_score"])) + features.append(p["embedding"]) + clss.append(0) + det = np.array(det) + confs = np.array(confs) + clss = np.array(clss) + features = torch.Tensor(features) + + xywhs = xyxy2xywh(det) + + # pass detections to deepsort + if c_box: + im0 = np.zeros((c_box[3] - c_box[1], c_box[2] - c_box[0])) + else: + im0 = np.zeros((video_map["height"], video_map["width"])) + outputs = tracker.update( + xywhs, confs, clss, im0, use_yolo_preds=True, features=features + ) + + assert len(pred) == len(outputs) + for j, output in enumerate(outputs): + bboxes = output[0:4] + id = output[4] + + min_box_distance = np.inf + match_p = None + for p in pred: + if "trackid" not in p: + c_box_distance = abs( + bboxes - np.array(p["bbox"], dtype=np.int) + ).sum() + if c_box_distance < 10 and c_box_distance < min_box_distance: + match_p = p + min_box_distance = c_box_distance + if match_p: + match_p["trackid"] = str(id) + else: + print("not match: ", frame_idx, bboxes) + for p in pred: + print(p["bbox"]) + + else: + tracker.increment_ages() + return video_map + + +class FaceTrackerByYolo5DeepSort(object): + def __init__( + self, + config_file, + device, + deep_sort_model="osnet_ibn_x1_0_MSMT17", + half: bool=False, + + ) -> None: + from deep_sort.utils.parser import get_config + from deep_sort.deep_sort import DeepSort + cfg = get_config() + cfg.merge_from_file(config_file) + # Create as tracker + self.tracker = DeepSort( + deep_sort_model, + device, + max_dist=cfg.DEEPSORT.MAX_DIST, + max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE, + max_age=cfg.DEEPSORT.MAX_AGE, + n_init=cfg.DEEPSORT.N_INIT, + nn_budget=cfg.DEEPSORT.NN_BUDGET, + ) + + def __call__(self, args, video_path, video_map, **kwds) -> Dict: + """_summary_ + + Args: + args (_type_): _description_ + video_path (_type_): _description_ + save_path (_type_): _description_ + map_path (_type_): _description_ + kwds: + # parser.add_argument('--yolo_model', nargs='+', type=str, default='yolov5m.pt', help='model.pt path(s)') + parser.add_argument('--deep_sort_model', type=str, default='osnet_ibn_x1_0_MSMT17') + # parser.add_argument('--source', type=str, default='0', help='source') # file/folder, 0 for webcam + '--output', type=str, default='inference/output', help='output folder' + ) # output folder + '--imgsz', + '--img', + '--img-size', + nargs='+', + type=int, + default=[640], + help='inference size h,w',) + '--conf-thres', type=float, default=0.5, help='object confidence threshold') + '--iou-thres', type=float, default=0.5, help='IOU threshold for NMS') + '--fourcc',type=str,default='mp4v', + help='output video codec (verify ffmpeg support)',) + '--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu') + '--show-vid', action='store_true', help='display tracking video results') + '--save-vid', action='store_true', help='save video tracking results') + '--save-txt', action='store_true', help='save MOT compliant results to *.txt') + # class 0 is person, 1 is bycicle, 2 is car... 79 is oven + '--classes', + nargs='+', + type=int, + help='filter by class: --class 0, or --class 16 17', + ) + '--agnostic-nms', action='store_true', help='class-agnostic NMS' + ) + parser.add_argument('--augment', action='store_true', help='augmented inference') + parser.add_argument('--update', action='store_true', help='update all models') + parser.add_argument('--evaluate', action='store_true', help='augmented inference') + parser.add_argument( + "--config_deepsort", type=str, default="deep_sort/configs/deep_sort.yaml" + ) + "--half", action="store_true", help="use FP16 half-precision inference" + ) + parser.add_argument('--visualize', action='store_true', help='visualize features') + '--max-det', type=int, default=1000, help='maximum detection per image' + ) + '--save-crop', action='store_true', help='save cropped prediction boxes' + ) + '--dnn', action='store_true', help='use OpenCV DNN for ONNX inference' + ) + '--project', default=ROOT / 'runs/track', help='save results to project/name' + ) + parser.add_argument('--name', default='exp', help='save results to project/name') + '--exist-ok', action='store_true', + help='existing project/name ok, do not increment', + ) + + '-src_path', + type=str, + default='/innovation_cfs/entertainment/VideoMashup/video_face_moviepy/10fps', + ) + '-map_path', type=str, + default='/innovation_cfs/entertainment/VideoMashup/video_map/transnetv2_duration_frameidx_moviepy', + + '-overwrite', default=False, action="store_true" + ) # whether overwrite the existing results + + + Returns: + Dict: _description_ + """ + video_info = detect(args, self.tracker, video_path, video_map, **kwds) + return video_info diff --git a/MuseV/MMCM/mmcm/vision/human/insightface_predictor.py b/MuseV/MMCM/mmcm/vision/human/insightface_predictor.py new file mode 100755 index 0000000000000000000000000000000000000000..86ec78c26c8a16f21bfe4ac7f3215ca9a26dced1 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/insightface_predictor.py @@ -0,0 +1,102 @@ +# -*- coding: utf-8 -*- +""" +Created on Tue Sep 8 13:31:25 2020 + +@author: infguo +""" + +import os +from typing import Dict +import argparse +import json +import traceback +import hashlib + +import cv2 +from moviepy.editor import VideoFileClip + +# TODO +# 该部分与源代码相比，修改了insight_face的输出接口，将性别分数透传出来，用于后续更精准的决策 + + +def inference(frame, app, max_face=10): + # Start to perform face recognition + try: # Handle exception + faces = app.get(frame, max_num=max_face) + except Exception as e: + print("is discarded due to exception {}!".format(e)) + return + + if ( + len(faces) == 0 + ): # If the landmarks cannot be detected, the img will be discarded + return + return faces + + +def predict(app, video_path, video_map, sample_fps): + from insightface.app import FaceAnalysis + + video_name = ".".join(video_path.split("/")[-1].split(".")[:-1]) + # video_hash_code = (os.popen('md5sum {}'.format(video_path))).readlines()[0].split(' ')[0] + with open(video_path, "rb") as fd: + data = fd.read() + video_hash_code = hashlib.md5(data).hexdigest() + + assert video_hash_code == video_map["video_file_hash_code"] + + # Capture video + video = VideoFileClip(video_path) + video = video.crop(*video_map["content_box"]) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + width, height = video.size + print("fps, frame_count, width, height:", fps, total_frames, width, height) + + video_map["detect_fps"] = sample_fps + video_map["face_detections"] = [] + + cnt_frame, step = 0, 0 + + fps = video_map["sample_fps"] + for frame in video.iter_frames(fps=fps): + if cnt_frame >= step: + step += fps / sample_fps + frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) + faces = inference(frame, app, max_face=0) + if faces and len(faces) > 0: + for f in faces: + f["bbox"] = f["bbox"].tolist() + f["kps"] = f["kps"].tolist() + f["embedding"] = f["embedding"].tolist() + f["det_score"] = str(f["det_score"]) + f["gender"] = str(f["gender"]) + f["age"] = str(f["age"]) + else: + faces = None + video_map["face_detections"].append( + {"frame_idx": cnt_frame, "faces": faces} + ) + + cnt_frame += 1 + return video_map + + +class InsightfacePredictor(object): + def __init__( + self, + sample_fps=10, + ) -> None: + # Load models + self.sample_fps = sample_fps + self.app = FaceAnalysis( + allowed_modules=["detection", "genderage", "recognition"], + providers=["CUDAExecutionProvider"], + provider_options=[{"device_id": "0"}], + ) + self.app.prepare(ctx_id=0, det_thresh=0.3, det_size=(640, 640)) + + def __call__(self, video_path, video_map) -> Dict: + video_info = predict(video_path, video_map, sample_fps=self.sample_fps) + return video_info diff --git a/MuseV/MMCM/mmcm/vision/human/roles.py b/MuseV/MMCM/mmcm/vision/human/roles.py new file mode 100755 index 0000000000000000000000000000000000000000..b4b23ac14bc000d90779788078c01f731bfb1474 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/human/roles.py @@ -0,0 +1,22 @@ +import os +import json + + +def load_roles(path): + face_name_dataset = {} + for face_name in os.listdir(path): + for face_result_file in os.listdir(os.path.join(path, face_name)): + try: + face_result = json.load( + open( + os.path.join(path, face_name, face_result_file), + encoding='UTF-8', + ) + )["face_detections"] + if face_name in face_name_dataset: + face_name_dataset[face_name].append(face_result[0]["embedding"]) + else: + face_name_dataset[face_name] = [face_result[0]["embedding"]] + except: + print(face_name, face_result_file, "is wrong") + return face_name_dataset diff --git a/MuseV/MMCM/mmcm/vision/loss/__init__.py b/MuseV/MMCM/mmcm/vision/loss/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/loss/content_loss.py b/MuseV/MMCM/mmcm/vision/loss/content_loss.py new file mode 100755 index 0000000000000000000000000000000000000000..891616a86dcb3029ccf9db5bbdaaff48e33a7922 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/loss/content_loss.py @@ -0,0 +1,43 @@ + +from typing import List, Union, Callable + +import torch +import torch.nn as nn + +from .multi_layer_loss import MultiLayerLoss + + +class ContentLoss(nn.Module): + def __init__(self, model: nn.Module, loss_fn: nn.Module=nn.MSELoss, weights: List[float] = None, transform: Callable=None,) -> None: + super().__init__() + self.model = model + self.loss_fn = loss_fn + self.weights = weights + self.transform = transform + + def forward(self, output: torch.Tensor, target: torch.Tensor) -> torch.Tensor: + """_summary_ + + Args: + output (torch.Tensor): b * c * h * w + + Returns: + torch.Tensor: _description_ + """ + + if self.transform is not None: + output = self.transform(output) + target = self.transform(target) + output_feature = self.model(output) + target_feature = self.model(target) + assert len(output_feature) == len(target_feature) + keys = sorted(output_feature.keys()) + total_loss = 0 + for i, k in enumerate(keys): + loss = self.loss_fn(output_feature[k], target_feature[k]) + print(i, k, loss) + if self.weights is not None: + loss *= self.weights[i] + total_loss += loss + return total_loss + diff --git a/MuseV/MMCM/mmcm/vision/loss/multi_layer_loss.py b/MuseV/MMCM/mmcm/vision/loss/multi_layer_loss.py new file mode 100755 index 0000000000000000000000000000000000000000..86c78dd28d9abb1fcbac452452dea308021afa3c --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/loss/multi_layer_loss.py @@ -0,0 +1,47 @@ + +from typing import List, Union + +import torch +import torch.nn as nn + + +class MultiLayerLoss(nn.Module): + def __init__(self, loss_fn: nn.Module, weights: List[float]=None) -> None: + super().__init__() + self.weights = weights + self.loss_fn = loss_fn + + def forward(self, output: Union[torch.Tensor, List[torch.tensor]], target: Union[torch.Tensor, List[torch.tensor]]) -> torch.Tensor: + """_summary_ + + Args: + output (torch.Tensor): b * c * h * w + + Returns: + torch.Tensor: _description_ + """ + if not isinstance(output, List): + output = [output] + if not isinstance(target, list): + target = [target] + assert len(output) == len(target), f"length of x({len(output)}) must be equal to target({len(target)})" + if self.weights is not None: + assert len(output) == len(self.weights), f"weights should be None or length of x({len(output)}) must be equal to weights({len(self.weights)})" + + total_loss = 0 + for i in range(len(output)): + x = output[i] + y = target[i] + x = self._get_feature(x) + y = self._get_feature(y) + loss = self.loss_fn(x, y) + if self.weights is not None: + loss *= self.weights[i] + total_loss += loss + return total_loss + + def cal_single_layer_loss(self, x, y): + raise NotImplementedError + + def _get_feature(self, x): + raise NotImplementedError \ No newline at end of file diff --git a/MuseV/MMCM/mmcm/vision/loss/style_loss.py b/MuseV/MMCM/mmcm/vision/loss/style_loss.py new file mode 100755 index 0000000000000000000000000000000000000000..5cf9870e8f7fcb08910019cf16dc0997ec58f5cf --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/loss/style_loss.py @@ -0,0 +1,25 @@ + +from typing import List, Union + +import torch +import torch.nn as nn + +from .multi_layer_loss import MultiLayerLoss + + +class StyleLoss(MultiLayerLoss): + def __init__(self, loss_fn: nn.Module=nn.MSELoss, weights: List[float] = None) -> None: + super().__init__(loss_fn, weights) + + def cal_single_layer_loss(self, x, y): + b, c, h, w = x.shape + loss = self.loss_fn(x, y) / (c * h * w) ** 2 / 4 + return loss + + def _get_feature(self, x: torch.Tensor) -> torch.Tensor: + b, c, h, w = x.shape + x = x.view(b, c, h * w) + gram = x.mul(x, x.transpose(1, 2)) + return gram + + diff --git a/MuseV/MMCM/mmcm/vision/loss/temporal_loss.py b/MuseV/MMCM/mmcm/vision/loss/temporal_loss.py new file mode 100755 index 0000000000000000000000000000000000000000..e14315d3a95ffd4b847aebc6d1d3e98f2ac6ecd2 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/loss/temporal_loss.py @@ -0,0 +1,53 @@ +from typing import List, Union + +import torch +import torch.nn as nn +from .multi_layer_loss import MultiLayerLoss + +from ..flow.util import torch_wrap + + +class FlowShortTermLoss(nn.Module): + def __init__(self, loss_fn: nn.Module = nn.MSELoss) -> None: + super().__init__() + self.loss_fn = loss_fn + + def forward(self, output, wrap): + b, c, h, w = output.shape + loss = self.loss_fn(output, wrap) + return loss + + +class FlowLongTermLoss(MultiLayerLoss): + def __init__(self, loss_fn: nn.Module, weights: List[float] = None) -> None: + super().__init__(loss_fn, weights) + + def forward( + self, outputs: List[torch.tensor], wraps: List[torch.tensor] + ) -> torch.Tensor: + """_summary_ + + Args: + output (torch.Tensor): b * c * h * w + + Returns: + torch.Tensor: _description_ + """ + assert len(outputs) == len( + wraps + ), f"length should be x({len(outputs)}) == target({len(wraps)})" + if self.weights is not None: + assert len(outputs) == len( + self.weights + ), f"weights should be None or length of x({len(outputs)}) must be equal to target({len(self.weights)})" + + total_loss = 0 + for i in len(outputs): + b, c, h, w = output.shape + output = outputs[i] + wrap = wraps[i] + loss = self.loss_fn(output, wrap) # mseloss reduce=mean + if self.weights is not None: + loss *= self.weights[i] + total_loss += loss + return total_loss diff --git a/MuseV/MMCM/mmcm/vision/loss/tv_loss.py b/MuseV/MMCM/mmcm/vision/loss/tv_loss.py new file mode 100755 index 0000000000000000000000000000000000000000..cc1b57b38bc285bf8cf6c418be31cb59f7765f04 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/loss/tv_loss.py @@ -0,0 +1,24 @@ +import torch +import torch.nn as nn + + +class TVLoss(nn.Module): + def __init__(self) -> None: + super().__init__() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """_summary_ + + Args: + x (torch.Tensor): b * c * h * w + + Returns: + torch.Tensor: _description_ + """ + b, c, h, w = x.shape + count_h = b * (h - 1) * w * c + count_w = b * h * (w - 1) * c + h_tv = (torch.pow((x[:,:,1:,:]-x[:,:,:-1,:]),2) / count_h).sum() + w_tv = (torch.pow((x[:,:,:,1:]-x[:,:,:,:-1]),2) / count_w).sum() + loss = 2 * (h_tv + w_tv) + return loss diff --git a/MuseV/MMCM/mmcm/vision/process/__init__.py b/MuseV/MMCM/mmcm/vision/process/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/process/correct_color.py b/MuseV/MMCM/mmcm/vision/process/correct_color.py new file mode 100644 index 0000000000000000000000000000000000000000..6edf00db0d7f053f72e5166ee18e7e1b124aba74 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/process/correct_color.py @@ -0,0 +1,100 @@ +from einops import rearrange, repeat +import numpy as np +from copy import deepcopy + +import skimage + +from ..data.video_dataset import DecordVideoDataset + + +def hist_match_color( + image: np.ndarray, reference: np.ndarray, channel_axis: int = -1 +) -> np.ndarray: + """rgb hwc 255 + + Args: + image (np.ndarray): h w c + reference (np.ndarray): h w c + + Returns: + np.ndarray: _description_ + """ + res = skimage.exposure.match_histograms(image, reference, channel_axis=channel_axis) + return res + + +def hist_match_color_video( + video: np.ndarray, target: np.ndarray, channel_axis: int = -1 +) -> np.ndarray: + """rgb hw c + + Args: + video (np.array): t h w c + target (np.array): h w c + + Returns: + np.array: t h w c + """ + new_video = [] + for t in range(len(video)): + image = hist_match_color(video[t, ...], target, channel_axis=channel_axis) + new_video.append(image) + new_video = np.stack(new_video, axis=0) + return new_video + + +def hist_match_color_video_batch( + video: np.ndarray, target: np.ndarray, channel_axis: int = -1 +) -> np.ndarray: + """rgb hw c + + Args: + video (np.array): b t h w c + target (np.array): b h w c + + Returns: + np.array: t h w c + """ + new_video = [] + for b in range(len(video)): + image = hist_match_color_video( + video[b, ...], target[b], channel_axis=channel_axis + ) + new_video.append(image) + new_video = np.stack(new_video, axis=0) + return new_video + + +def hist_match_color_videodataset( + video: DecordVideoDataset, target: np.ndarray, channel_axis: int = -1 +) -> np.ndarray: + """rgb t h w c + + Args: + video (DecordVideoDataset): t h w c + target (np.ndarray): h w c + + Returns: + np.ndarray: t h w c + """ + new_video = [] + for i, batch in enumerate(video): + batch_data = batch.data + new_batch = hist_match_color_video( + batch_data, target, channel_axis=channel_axis + ) + new_video.append(new_batch) + new_video = np.concatenate(new_video, axis=0) + return new_video + + +def hist_match_video_bcthw(video, target, value: float = 255.0): + video = rearrange(video, "b c t h w-> b t h w c") + target = rearrange(target, "b c t h w->(b t) h w c") + video = (video * value).astype(np.uint8) + target = (target * value).astype(np.uint8) + video = hist_match_color_video_batch(video, target) + video = video / value + target = target / value + video = rearrange(video, "b t h w c->b c t h w") + return video diff --git a/MuseV/MMCM/mmcm/vision/process/image_process.py b/MuseV/MMCM/mmcm/vision/process/image_process.py new file mode 100755 index 0000000000000000000000000000000000000000..db394e54f590ded93944c7b4b7de2668cb043f4e --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/process/image_process.py @@ -0,0 +1,285 @@ +from einops import rearrange +import requests +from io import BytesIO +from typing import Literal, Union +import math + +from PIL import Image + +import numpy as np +from diffusers.utils import load_image +import cv2 +import torch + +from mmcm.vision.utils.data_type_util import convert_images +from transformers.models.clip.image_processing_clip import to_numpy_array +from ..utils.vision_util import round_up_to_even + + +def get_image_from_input(image: Union[str, Image.Image]) -> Image.Image: + if isinstance(image, str): + if "http" in image: + image = BytesIO(requests.get(image).content) + image = Image.open(image).convert("RGB") + else: + image = Image.open(image).convert("RGB") + else: + image = image.convert("RGB") + assert type(image) == Image.Image + return image + + +def dynamic_resize_image( + image: Image.Image, + target_height: int, + target_width: int, + image_max_length: int = 910, +) -> Image.Image: + """对图像进行预处理，目前会将短边resize到目标长度，同时限制长边长度 + + Args: + image (Image.Image): _description_ + target_height (int): _description_ + target_width (int): _description_ + image_max_length (int): _description_ + + Returns: + Image.Image: _description_ + """ + w, h = image.size + if w > h: + target_width = min(math.ceil(w * target_height / h), image_max_length) + target_height = math.ceil(target_width / w * h) + else: + target_height = min(math.ceil(h * target_width / w), image_max_length) + target_width = math.ceil(target_height / h * w) + target_width = round_up_to_even(target_width) + target_height = round_up_to_even(target_height) + image = image.resize((target_width, target_height)) + return image + + +def dynamic_crop_resize_image( + image: Image.Image, + target_height: int, + target_width: int, + resample=None, +) -> Image.Image: + """获取图像有效部分，并resize到对应目标宽度和高度。 + 如果图像宽高比大于 target_width / target_height，则保留全部高，截取宽的中心部位； + 如果图像宽高比小于 target_width / target_height，则保留全部宽，截取高的中心部位； + 最后，将截取的图像resize到目标宽高 + Args: + image (Image.Image): 输入图像 + target_height (int): 目标高 + target_width (int): 目标宽 + + Returns: + Image.Image: 动态截取、resize生成的图像 + """ + w, h = image.size + image_width_heigt_ratio = w / h + target_width_height_ratio = target_width / target_height + if image_width_heigt_ratio >= target_width_height_ratio: + y1 = 0 + y2 = h - 1 + x1 = math.ceil((w - h * target_width / target_height) / 2) + x2 = math.ceil(w - (w - h * target_width / target_height) / 2) + else: + x1 = 0 + x2 = w - 1 + y1 = math.ceil((h - w * target_height / target_width) / 2) + y2 = math.ceil(h - (h - w * target_height / target_width) / 2) + x1 = max(0, x1) + x2 = min(x2, w - 1) + y1 = max(0, y1) + y2 = min(y2, h - 1) + image = image.crop((x1, y1, x2, y2)) + image = image.resize((target_width, target_height), resample=resample) + return image + + +def get_canny( + image: np.ndarray, low_threshold: float, high_threshold: float +) -> np.ndarray: + image = cv2.Canny(image, low_threshold, high_threshold) + image = image[:, :, None] + image = np.concatenate([image, image, image], axis=2) + return image + + +def pad_matrix(matrix, target_shape): + h, w, c = matrix.shape + h1, w1 = target_shape + + if h1 < h or w1 < w: + raise ValueError("Target shape must be larger than original shape.") + + pad_h = (h1 - h) // 2 + pad_w = (w1 - w) // 2 + + padded_matrix = np.zeros((h1, w1, c)) + padded_matrix[pad_h : pad_h + h, pad_w : pad_w + w, :] = matrix + + return padded_matrix + + +def pad_tensor(tensor, shape): + """ + 将输入的numpy array tensor进行0填充，直到其尺寸达到目标尺寸shape。 + + 参数： + tensor: numpy array，输入的tensor + shape: tuple，目标尺寸 + + 返回值： + numpy array，填充后的tensor + """ + # 获取tensor的尺寸 + tensor_shape = tensor.shape + # 计算需要填充的尺寸 + pad_shape = tuple( + np.maximum(np.zeros_like(shape), np.array(shape) - np.array(tensor_shape)) + ) + # pad_shape = (np.max(0, shape[i] - tensor_shape[i]) for i in range(len(shape))) + # 构造填充后的tensor + pad_shape_ = ((0, x) for x in pad_shape) + padded_tensor = np.pad( + tensor, + ((0, pad_shape[0]), (0, pad_shape[1]), (0, pad_shape[2]), (0, pad_shape[3])), + # pad_shape_, + mode="constant", + ) + return padded_tensor + + +def batch_dynamic_crop_resize_images_v2( + images: Union[torch.Tensor, np.ndarray], + target_height: int, + target_width: int, + mode=Image.Resampling.LANCZOS, +) -> np.ndarray: + """获取图像中心有效部分，并resize到对应目标宽度和高度。 + 如果图像宽高比大于 target_width / target_height，则保留全部高，截取宽的中心部位； + 如果图像宽高比小于 target_width / target_height，则保留全部宽，截取高的中心部位； + 最后，将截取的图像resize到目标宽高 + Args: + image (Image.Image): 输入图像 + target_height (int): 目标高 + target_width (int): 目标宽 + + Returns: + Image.Image: 动态截取、resize生成的图像 + """ + ndim = images.ndim + if ndim == 4: + b, c, h, w = images.shape + elif ndim == 5: + b, c, t, h, w = images.shape + images = rearrange(images, "b c t h w->(b t) c h w") + else: + raise ValueError(f"ndim only support 4, 5 but given {ndim}") + images = convert_images( + images, data_channel_order="b c h w", return_type="pil", input_rgb_order="rgb" + ) + images = [ + dynamic_crop_resize_image( + image, + target_height=target_height, + target_width=target_width, + resample=mode, + ) + for image in images + ] + images = [to_numpy_array(x) for x in images] + images = np.stack(images, axis=0) + images = rearrange(images, "b h w c-> b c h w") + if ndim == 5: + images = rearrange(images, "(b t) c h w->b c t h w", b=b, t=t) + return images + + +def batch_dynamic_crop_resize_images( + images: Union[torch.Tensor, np.ndarray], + target_height: int, + target_width: int, + mode: Literal[ + "nearest", "linear", "bilinear", "bicubic", "trilinear", "area", "nearest-exact" + ] = "bilinear", + # ] = "nearest", + align_corners=False, +) -> torch.TensorType: + """获取图像中心有效部分，并resize到对应目标宽度和高度。 + 如果图像宽高比大于 target_width / target_height，则保留全部高，截取宽的中心部位； + 如果图像宽高比小于 target_width / target_height，则保留全部宽，截取高的中心部位； + 最后，将截取的图像resize到目标宽高 + + Warning: 该方法对于 b c t h w t=1时 会出现图像像素错位问题，所以新增了个使用Image.Resize的V2版本 + Args: + image (Image.Image): 输入图像 + target_height (int): 目标高 + target_width (int): 目标宽 + + Returns: + Image.Image: 动态截取、resize生成的图像 + """ + if isinstance(images, np.ndarray): + images = torch.from_numpy(images) + ndim = images.ndim + + if ndim == 4: + b, c, h, w = images.shape + elif ndim == 5: + b, c, t, h, w = images.shape + images = rearrange(images, "b c t h w->(b t) c h w") + else: + raise ValueError(f"ndim only support 4, 5 but given {ndim}") + image_width_heigt_ratio = w / h + target_width_height_ratio = target_width / target_height + if image_width_heigt_ratio >= target_width_height_ratio: + y1 = 0 + y2 = h - 1 + x1 = math.ceil((w - h * target_width / target_height) / 2) + x2 = math.ceil(w - (w - h * target_width / target_height) / 2) + else: + x1 = 0 + x2 = w - 1 + y1 = math.ceil((h - w * target_height / target_width) / 2) + y2 = math.ceil(h - (h - w * target_height / target_width) / 2) + x1 = max(0, x1) + x2 = min(x2, w - 1) + y1 = max(0, y1) + y2 = min(y2, h - 1) + images = images[:, :, y1:y2, x1:x2] + images = torch.nn.functional.interpolate( + images, + (target_height, target_width), + mode=mode, # align_corners=align_corners + ) + if ndim == 5: + images = rearrange(images, "(b t) c h w->b c t h w", b=b, t=t) + return images + + +def his_match(src: np.ndarray, dst: np.ndarray) -> np.ndarray: + src = src * 255.0 + dst = dst * 255.0 + src = src.astype(np.uint8) + dst = dst.astype(np.uint8) + res = np.zeros_like(dst) + + cdf_src = np.zeros((3, 256)) + cdf_dst = np.zeros((3, 256)) + cdf_res = np.zeros((3, 256)) + kw = dict(bins=256, range=(0, 256), density=True) + for ch in range(3): + his_src, _ = np.histogram(src[:, :, ch], **kw) + hist_dst, _ = np.histogram(dst[:, :, ch], **kw) + cdf_src[ch] = np.cumsum(his_src) + cdf_dst[ch] = np.cumsum(hist_dst) + index = np.searchsorted(cdf_src[ch], cdf_dst[ch], side="left") + np.clip(index, 0, 255, out=index) + res[:, :, ch] = index[dst[:, :, ch]] + his_res, _ = np.histogram(res[:, :, ch], **kw) + cdf_res[ch] = np.cumsum(his_res) + return res / 255.0 diff --git a/MuseV/MMCM/mmcm/vision/process/inference_video.py b/MuseV/MMCM/mmcm/vision/process/inference_video.py new file mode 100755 index 0000000000000000000000000000000000000000..981b79e92741bc08cf323aa18c4355fc204f9da8 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/process/inference_video.py @@ -0,0 +1,15 @@ +from typing import Callable + +from ..data.video_dataset import SequentialDataset +# import torchvision.transforms.transforms import + + +def inference_video(video_dataset: SequentialDataset, predictor: Callable, transform:Callable=None, post_process: Callable=None): + results = [] + for data in video_dataset: + if transform is not None: + data = transform(data) + data = predictor(data) + if post_process is not None: + results = post_process(results) + return results diff --git a/MuseV/MMCM/mmcm/vision/track/__Init__.py b/MuseV/MMCM/mmcm/vision/track/__Init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/transition/TransNetV2/TransNetmodels.py b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/TransNetmodels.py new file mode 100755 index 0000000000000000000000000000000000000000..70447ce1759d7e951a8d74e7caab105ec6b435d2 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/TransNetmodels.py @@ -0,0 +1,608 @@ +import random + +import torch +from torch import nn +import torch.nn.functional as F +import ffmpeg +import numpy as np +import cv2 +from moviepy.editor import VideoFileClip + +from .utils import get_frames + + +class TransNetV2(nn.Module): + def __init__(self, F=16, L=3, S=2, D=1024): + super(TransNetV2, self).__init__() + self.SDDCNN = nn.ModuleList( + [ + StackedDDCNNV2( + in_filters=3, n_blocks=S, filters=F, stochastic_depth_drop_prob=0.0 + ) + ] + + [ + StackedDDCNNV2( + in_filters=(F * 2 ** (i - 1)) * 4, n_blocks=S, filters=F * 2**i + ) + for i in range(1, L) + ] + ) + + # 帧相似网络 + self.frame_sim_layer = FrameSimilarity( + sum([(F * 2**i) * 4 for i in range(L)]), + lookup_window=101, + output_dim=128, + similarity_dim=128, + use_bias=True, + ) + + # 颜色相似网络 + self.color_hist_layer = ColorHistograms(lookup_window=101, output_dim=128) + + # dropout + self.dropout = nn.Dropout(0.5) + + output_dim = ((F * 2 ** (L - 1)) * 4) * 3 * 6 # + output_dim = output_dim + 128 # 使用了帧相似网络, 维度需要加128 + output_dim = output_dim + 128 # 使用了颜色相似网络, 维度需要再加128 + + self.fc1 = nn.Linear(output_dim, D) + self.cls_layer1 = nn.Linear(D, 1) + self.cls_layer2 = nn.Linear(D, 1) + + def forward(self, inputs): + # 输入必须为torch.uint8, (h,w)=(27,48)的图片batch样本 + # assert isinstance(inputs, torch.Tensor) and list(inputs.shape[2:]) == [27, 48, 3] and inputs.dtype == torch.uint8, "incorrect input type and/or shape" + + # uint8 of shape [B, T, H, W, 3] to float of shape [B, 3, T, H, W] + with torch.autograd.set_detect_anomaly(True): + x = inputs.permute([0, 4, 1, 2, 3]).float() + x = x.div_(255.0) + + # 收集每一层的SDDCNN特征图 + block_features = [] + for block in self.SDDCNN: + x = block(x) + block_features.append(x) + + x = x.permute(0, 2, 3, 4, 1) # 把维度从[B, 通道数, T, H, W] 转化为 [B, T, H, W, 通道数] + x = x.reshape(x.shape[0], x.shape[1], -1) + + x = torch.cat( + [self.frame_sim_layer(block_features), x], 2 + ) # 在最后一维度cat上block_features输出的特征 + x = torch.cat( + [self.color_hist_layer(inputs), x], 2 + ) # 在最后一维度cat上color_hist_layer输出的特征 + + x = F.relu(self.fc1(x)) + x = self.dropout(x) + + one_hot = self.cls_layer1(x) + many_hot = self.cls_layer2(x) + return one_hot, many_hot + + # 预测MP4文件转换帧，并给出对应帧位置 + def predict_video( + self, + mp4_file, + cache_path="", + c_box=None, + width=48, + height=27, + input_frames=100, + overlap=30, + sample_fps=30, + threshold=0.3, + ): + """ + mp4_file: ~/6712566330782010632.mp4 + cache_path: ~/视频单帧数据_h48_w27 + return: [x,x,...] 点位时间 + """ + assert overlap % 2 == 0 + assert input_frames > overlap + # fps = eval(ffmpeg.probe(mp4_file)['streams'][0]['r_frame_rate']) # 获取视频的视频帧率 + # total_frames = int(ffmpeg.probe(mp4_file)['streams'][0]['nb_frames']) # 获取视频的总帧数 + # duration = float(ffmpeg.probe(mp4_file)['streams'][0]['duration']) # 获取视频的总时长 + video = VideoFileClip(mp4_file) + # video = video.subclip(0, 60 * 10) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + w, h = video.size + print(fps, duration, total_frames, w, h) + + if c_box: + video.crop(*c_box) + + frame_iter = video.iter_frames(fps=sample_fps) + sample_total_frames = int(sample_fps * duration) + frame_list = [] + for i in range(sample_total_frames // (input_frames - overlap) + 1): + # if i==1: + # break + frame_list = frame_list[-overlap:] + start_frame = i * (input_frames - overlap) + end_frame = min(start_frame + input_frames, sample_total_frames) + print("start_frame & end_frame: ", start_frame, end_frame) + for frame in frame_iter: + frame = cv2.resize(frame, (width, height)) + frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) + frame_list.append(frame) + if len(frame_list) == end_frame - start_frame: + break + frames = torch.Tensor(frame_list) # 获得帧 + if frames.shape[0] < end_frame - start_frame: + # 原视频的视频时长比音频时长短，体现出来的是原视频最后有声音没画面 + print( + "total_frames is wrong: ", + total_frames, + "-->", + start_frame + frames.shape[0], + ) + # sample_total_frames = start_frame + frames.shape[0] + # fps = total_frames / duration + frames = frames.cuda() + # single_frame_pred和all_frame_pred都是输出window_size长的是否转场概率， + single_frame_pred, all_frame_pred = self.forward( + frames.unsqueeze(0) + ) # 前向推理 + # single_frame_pred = F.softmax(single_frame_pred, dim=-1) # 获得每一帧对应的类别概率 + # single_frame_pred = torch.argmax(single_frame_pred, dim=-1).reshape(-1) + single_frame_pred = torch.sigmoid(single_frame_pred).reshape(-1) + all_frame_pred = torch.sigmoid(all_frame_pred).reshape(-1) + + # single_frame_pred = (single_frame_pred>threshold)*1 + if total_frames > end_frame: + if i == 0: + single_frame_pred_label = single_frame_pred[: -overlap // 2] + all_frame_pred_label = all_frame_pred[: -overlap // 2] + else: + single_frame_pred_label = torch.cat( + ( + single_frame_pred_label, + single_frame_pred[overlap // 2 : -overlap // 2], + ), + dim=0, + ) + all_frame_pred_label = torch.cat( + ( + all_frame_pred_label, + all_frame_pred[overlap // 2 : -overlap // 2], + ), + dim=0, + ) + else: + if i == 0: + single_frame_pred_label = single_frame_pred + all_frame_pred_label = all_frame_pred + else: + single_frame_pred_label = torch.cat( + (single_frame_pred_label, single_frame_pred[overlap // 2 :]), + dim=0, + ) + all_frame_pred_label = torch.cat( + (all_frame_pred_label, all_frame_pred[overlap // 2 :]), dim=0 + ) + break + + single_frame_pred_label = single_frame_pred_label.cpu().numpy() + all_frame_pred_label = all_frame_pred_label.cpu().numpy() + + return ( + single_frame_pred_label, + all_frame_pred_label, + fps, + total_frames, + duration, + h, + w, + ) + + # transition_index = torch.where(pred_label==1)[0].cpu().numpy() # 转场帧位置 + # transition_index = transition_index.astype(np.float) + # # 对返回结果做后处理合并相邻帧 + # result_transition = [] + # for i, transition in enumerate(transition_index): + # if i == 0: + # result_transition.append([transition]) + # else: + # if abs(result_transition[-1][-1]-transition) == 1: + # result_transition[-1].append(transition) + # else: + # result_transition.append([transition]) + # + # result_transition = [[0]] + [[item[0], item[-1]] if len(item)>1 else [item[0]] for item in result_transition] + [[total_frames]] + # + # return result_transition, fps, total_frames, duration, h, w + + def predict_video_2( + self, + mp4_file, + cache_path="", + c_box=None, + width=48, + height=27, + input_frames=100, + overlap=30, + sample_fps=30, + threshold=0.3, + ): + """ + mp4_file: ~/6712566330782010632.mp4 + cache_path: ~/视频单帧数据_h48_w27 + return: [x,x,...] 点位时间 + """ + assert overlap % 2 == 0 + assert input_frames > overlap + # fps = eval(ffmpeg.probe(mp4_file)['streams'][0]['r_frame_rate']) # 获取视频的视频帧率 + # total_frames = int(ffmpeg.probe(mp4_file)['streams'][0]['nb_frames']) # 获取视频的总帧数 + # duration = float(ffmpeg.probe(mp4_file)['streams'][0]['duration']) # 获取视频的总时长 + video = VideoFileClip(mp4_file) + # video = video.subclip(0, 60 * 10) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + w, h = video.size + print(fps, duration, total_frames, w, h) + + if c_box: + video.crop(*c_box) + + frame_iter = video.iter_frames(fps=sample_fps) + sample_total_frames = int(sample_fps * duration) + frame_list = [] + for i in range(sample_total_frames // (input_frames - overlap) + 1): + # if i==1: + # break + frame_list = frame_list[-overlap:] + start_frame = i * (input_frames - overlap) + end_frame = min(start_frame + input_frames, sample_total_frames) + print("start_frame & end_frame: ", start_frame, end_frame) + for frame in frame_iter: + frame = cv2.resize(frame, (width, height)) + frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) + frame_list.append(frame) + if len(frame_list) == end_frame - start_frame: + break + frames = torch.Tensor(frame_list) # 获得帧 + if frames.shape[0] < end_frame - start_frame: + # 原视频的视频时长比音频时长短，体现出来的是原视频最后有声音没画面 + print( + "total_frames is wrong: ", + total_frames, + "-->", + start_frame + frames.shape[0], + ) + # sample_total_frames = start_frame + frames.shape[0] + # fps = total_frames / duration + frames = frames.cuda() + single_frame_pred, all_frame_pred = self.forward( + frames.unsqueeze(0) + ) # 前向推理 + # single_frame_pred = F.softmax(single_frame_pred, dim=-1) # 获得每一帧对应的类别概率 + # single_frame_pred = torch.argmax(single_frame_pred, dim=-1).reshape(-1) + single_frame_pred = torch.sigmoid(single_frame_pred).reshape(-1) + all_frame_pred = torch.sigmoid(all_frame_pred).reshape(-1) + + # single_frame_pred = (single_frame_pred>threshold)*1 + if total_frames > end_frame: + if i == 0: + single_frame_pred_label = single_frame_pred[: -overlap // 2] + all_frame_pred_label = all_frame_pred[: -overlap // 2] + else: + single_frame_pred_label = torch.cat( + ( + single_frame_pred_label, + single_frame_pred[overlap // 2 : -overlap // 2], + ), + dim=0, + ) + all_frame_pred_label = torch.cat( + ( + all_frame_pred_label, + all_frame_pred[overlap // 2 : -overlap // 2], + ), + dim=0, + ) + else: + if i == 0: + single_frame_pred_label = single_frame_pred + all_frame_pred_label = all_frame_pred + else: + single_frame_pred_label = torch.cat( + (single_frame_pred_label, single_frame_pred[overlap // 2 :]), + dim=0, + ) + all_frame_pred_label = torch.cat( + (all_frame_pred_label, all_frame_pred[overlap // 2 :]), dim=0 + ) + break + + single_frame_pred_label = single_frame_pred_label.cpu().numpy() + all_frame_pred_label = all_frame_pred_label.cpu().numpy() + + return ( + single_frame_pred_label, + all_frame_pred_label, + fps, + total_frames, + duration, + h, + w, + ) + + +class StackedDDCNNV2(nn.Module): + def __init__( + self, + in_filters, + n_blocks, + filters, + shortcut=True, + pool_type="avg", + stochastic_depth_drop_prob=0.0, + ): + super(StackedDDCNNV2, self).__init__() + + self.shortcut = shortcut + # 定义DDCNN层 + self.DDCNN = nn.ModuleList( + [ + DilatedDCNNV2( + in_filters if i == 1 else filters * 4, + filters, + activation=F.relu if i != n_blocks else None, + ) + for i in range(1, n_blocks + 1) + ] + ) # 有n_blocks层数量的DilateDCNNV2模块 + + # 定义pool层 + self.pool = ( + nn.MaxPool3d(kernel_size=(1, 2, 2)) + if pool_type == "max" + else nn.AvgPool3d(kernel_size=(1, 2, 2)) + ) + self.stochastic_depth_drop_prob = stochastic_depth_drop_prob + + def forward(self, inputs): + x = inputs + shortcut = None + + # DDCNN层前向传播 + for block in self.DDCNN: + x = block(x) + if shortcut is None: # 记录第一层的结果作为残差连接 + shortcut = x + + x = F.relu(x) + if self.shortcut is not None: + if self.stochastic_depth_drop_prob != 0.0: + if self.training: + if random.random() < self.stochastic_depth_drop_prob: + x = shortcut + else: + x = x + shortcut + else: + x = (1 - self.stochastic_depth_drop_prob) * x + shortcut + else: + x = x + shortcut + + x = self.pool(x) + return x + + +class DilatedDCNNV2(nn.Module): + def __init__(self, in_filters, filters, batch_norm=True, activation=None): + super(DilatedDCNNV2, self).__init__() + + self.Conv3D_1 = Conv3DConfigurable( + in_filters, filters, 1, use_bias=not batch_norm + ) + self.Conv3D_2 = Conv3DConfigurable( + in_filters, filters, 2, use_bias=not batch_norm + ) + self.Conv3D_4 = Conv3DConfigurable( + in_filters, filters, 4, use_bias=not batch_norm + ) + self.Conv3D_8 = Conv3DConfigurable( + in_filters, filters, 8, use_bias=not batch_norm + ) + + self.bn = nn.BatchNorm3d(filters * 4, eps=1e-3) if batch_norm else None + self.activation = activation # 激活函数定义 + + def forward(self, inputs): + conv1 = self.Conv3D_1(inputs) + conv2 = self.Conv3D_2(inputs) + conv3 = self.Conv3D_4(inputs) + conv4 = self.Conv3D_8(inputs) + + x = torch.cat([conv1, conv2, conv3, conv4], dim=1) + + if self.bn is not None: + x = self.bn(x) + + if self.activation is not None: + x = self.activation(x) + + return x + + +class Conv3DConfigurable(nn.Module): + def __init__( + self, in_filters, filters, dilation_rate, separable=True, use_bias=True + ): + super(Conv3DConfigurable, self).__init__() + + if separable: + # (2+1)D convolution https://arxiv.org/pdf/1711.11248.pdf + conv1 = nn.Conv3d( + in_filters, + 2 * filters, + kernel_size=(1, 3, 3), + dilation=(1, 1, 1), + padding=(0, 1, 1), + bias=False, + ) + conv2 = nn.Conv3d( + 2 * filters, + filters, + kernel_size=(3, 1, 1), + dilation=(dilation_rate, 1, 1), + padding=(dilation_rate, 0, 0), + bias=use_bias, + ) + self.layers = nn.ModuleList([conv1, conv2]) + else: + conv = nn.Conv3d( + in_filters, + filters, + kernel_size=3, + dilation=(dilation_rate, 1, 1), + padding=(dilation_rate, 1, 1), + bias=use_bias, + ) + self.layers = nn.ModuleList([conv]) + + def forward(self, inputs): + x = inputs + for layer in self.layers: + x = layer(x) + return x + + +# 帧相似网络构建 +class FrameSimilarity(nn.Module): + def __init__( + self, + in_filters, + similarity_dim=128, + lookup_window=101, + output_dim=128, + use_bias=False, + ): + super(FrameSimilarity, self).__init__() + + self.projection = nn.Linear(in_filters, similarity_dim, bias=use_bias) + self.fc = nn.Linear(lookup_window, output_dim) + + self.lookup_window = lookup_window + assert lookup_window % 2 == 1, "`lookup_window` must be odd integer" + + def forward(self, inputs): + x = torch.cat([torch.mean(x, dim=[3, 4]) for x in inputs], dim=1) + x = torch.transpose(x, 1, 2) + + x = self.projection(x) + x = F.normalize(x, p=2, dim=2) + + batch_size, time_window = x.shape[0], x.shape[1] + similarities = torch.bmm( + x, x.transpose(1, 2) + ) # [batch_size, time_window, time_window]余弦相似度 + similarities_padded = F.pad( + similarities, [(self.lookup_window - 1) // 2, (self.lookup_window - 1) // 2] + ) + + batch_indices = ( + torch.arange(0, batch_size, device=x.device) + .view([batch_size, 1, 1]) + .repeat([1, time_window, self.lookup_window]) + ) + time_indices = ( + torch.arange(0, time_window, device=x.device) + .view([1, time_window, 1]) + .repeat([batch_size, 1, self.lookup_window]) + ) + lookup_indices = ( + torch.arange(0, self.lookup_window, device=x.device) + .view([1, 1, self.lookup_window]) + .repeat([batch_size, time_window, 1]) + + time_indices + ) + + similarities = similarities_padded[batch_indices, time_indices, lookup_indices] + return F.relu(self.fc(similarities)) + + +# 颜色相似网络 +class ColorHistograms(nn.Module): + def __init__(self, lookup_window=101, output_dim=None): + super(ColorHistograms, self).__init__() + + self.fc = ( + nn.Linear(lookup_window, output_dim) if output_dim is not None else None + ) + self.lookup_window = lookup_window + assert lookup_window % 2 == 1, "`lookup_window` must be odd integer" + + @staticmethod + def compute_color_histograms(frames): + frames = frames.int() + + def get_bin(frames): + # returns 0 .. 511 + R, G, B = frames[:, :, 0], frames[:, :, 1], frames[:, :, 2] + R, G, B = R >> 5, G >> 5, B >> 5 + return (R << 6) + (G << 3) + B + + batch_size, time_window, height, width, no_channels = frames.shape + assert no_channels == 3 + frames_flatten = frames.view(batch_size * time_window, height * width, 3) + + binned_values = get_bin(frames_flatten) + frame_bin_prefix = ( + torch.arange(0, batch_size * time_window, device=frames.device) << 9 + ).view(-1, 1) + binned_values = (binned_values + frame_bin_prefix).view(-1) + + histograms = torch.zeros( + batch_size * time_window * 512, dtype=torch.int32, device=frames.device + ) + histograms.scatter_add_( + 0, + binned_values, + torch.ones(len(binned_values), dtype=torch.int32, device=frames.device), + ) + + histograms = histograms.view(batch_size, time_window, 512).float() + histograms_normalized = F.normalize(histograms, p=2, dim=2) + return histograms_normalized + + def forward(self, inputs): + x = self.compute_color_histograms(inputs) + + batch_size, time_window = x.shape[0], x.shape[1] + similarities = torch.bmm( + x, x.transpose(1, 2) + ) # [batch_size, time_window, time_window] + similarities_padded = F.pad( + similarities, [(self.lookup_window - 1) // 2, (self.lookup_window - 1) // 2] + ) + + batch_indices = ( + torch.arange(0, batch_size, device=x.device) + .view([batch_size, 1, 1]) + .repeat([1, time_window, self.lookup_window]) + ) + time_indices = ( + torch.arange(0, time_window, device=x.device) + .view([1, time_window, 1]) + .repeat([batch_size, 1, self.lookup_window]) + ) + lookup_indices = ( + torch.arange(0, self.lookup_window, device=x.device) + .view([1, 1, self.lookup_window]) + .repeat([batch_size, time_window, 1]) + + time_indices + ) + + similarities = similarities_padded[batch_indices, time_indices, lookup_indices] + + if self.fc is not None: + return F.relu(self.fc(similarities)) + return similarities diff --git a/MuseV/MMCM/mmcm/vision/transition/TransNetV2/__init__.py b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/transition/TransNetV2/model_api.py b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/model_api.py new file mode 100755 index 0000000000000000000000000000000000000000..43ce294983211791eeca1f55ec0b2a365aafbed2 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/model_api.py @@ -0,0 +1,369 @@ +import warnings +import logging +import os +import pickle +import copy +import time + +import numpy as np +import pytorch_lightning as pl +import torch +from torch import nn +import torch.nn.functional as F + +from .TransNetmodels import TransNetV2 + +warnings.filterwarnings("ignore") +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +## 工具函数 +def complete_results_batch( + mp4_ids, + batch_mp4_scenes_index, + fps_batch, + single_frame_pred, + class_threshold, + cache_file="/data_share7/v_hyggewang/视频切换模型依赖数据/转场真实标签字典.pkl", +): + """ + single_frame_pred: [片段数, 100, 2] + return:[[xs,xs,xs...],[xs,xs..]]每个元素是对应视频的真实值 + """ + cache = pickle.load(open(cache_file, "rb")) # 读取储存好的MP4真实标签 + pre_index = 0 + result = [] + + for mp4_id, index, fps in zip(mp4_ids, batch_mp4_scenes_index, fps_batch): + raw_transition_index = single_frame_pred[ + pre_index : (pre_index + int(index)), 15:-15, : + ].reshape( + -1, 70, 2 + ) # 这里得到15-85，85-155...帧信息具体切割参看dataset中验证集数据生成。 + + raw_transition_index = F.softmax(raw_transition_index, dim=-1) # 获得每一帧对应的类别概率 + zero = torch.zeros_like(raw_transition_index) + one = torch.ones_like(raw_transition_index) + raw_transition_index = torch.where( + raw_transition_index < class_threshold, zero, one + )[ + :, :, -1 + ] # 只获取属于1标签的预测结果 + pred_label = raw_transition_index.reshape(-1) # 得到所有帧的结果 + + # raw_transition_index = F.softmax(raw_transition_index, dim=-1) # 获得每一帧对应的类别概率 + # pred_label = torch.argmax(raw_transition_index, dim=-1).reshape(-1) # 得到最终类别 + + transition_index = ( + torch.where(pred_label == 1)[0] + 15 + ) / fps # 转场帧位置(前15帧需要加入) + + # 对返回结果做后处理合并相邻帧 + result_transition = [] + for i, transition in enumerate(transition_index): + if i == 0: + result_transition.append([transition]) + else: + if abs(result_transition[-1][-1] - transition) < 0.035: + result_transition[-1].append(transition) + else: + result_transition.append([transition]) + result_transition_ = [ + np.mean(item, dtype=np.float16) for item in result_transition + ] # 得到最终预测结果 + + mp4_GT_label_transition = cache[int(mp4_id)] # 储存MP4过渡转场真实标签 + result.append({"真实标签": mp4_GT_label_transition, "预测标签": result_transition_}) + pre_index = pre_index + int(index) + + return result + + +### 工具函数 +def pr_call(label_list, thresholds=[0.1, 0.3, 0.5, 0.7]): + """ + 根据时间误差返回各个时间误差情况下的，召回度和准确度 + """ + correct_num_dict = {threshold: 0 for threshold in thresholds} # 记录各个阈值下准确预测个数 + result = {threshold: None for threshold in thresholds} # 记录各个阈值下，准确度和召回度 + pre_positive_num = 0 # 所有样本预测正例个数 + GT_positive_num = 0 # 所有样本真实正例个数 + for label_dic in label_list: + true_labels, pre_labels = label_dic["真实标签"], label_dic["预测标签"] + pre_positive_num += len(pre_labels) + GT_positive_num += len(true_labels) + + for threshold in thresholds: + pre_label_used = set() # 记录已经匹配的预测标签防止重复匹配 + for true_label in true_labels: + matched = False # 真值是否被匹配上了 + for pre_label in pre_labels: + if pre_label > true_label + threshold: # 如果预测值大于了阈值范围，则跳过剩下的预测值 + break + if pre_label in pre_label_used: # 如果该标签已经被匹配上了则跳过匹配 + continue + if ( + (true_label - threshold) + <= pre_label + <= (true_label + threshold) + ): + correct_num_dict[threshold] += 1 + matched = True + if matched: # 如果真值已经被匹配上了，则跳过剩下的预测值 + pre_label_used.add(pre_label) # 增加已经匹配上的标签 + break + for item in correct_num_dict.items(): + result[item[0]] = { + "precision": item[1] / (pre_positive_num + 1e-8), + "recall": item[1] / (GT_positive_num + 1e-8), + } + return result + + +class MInterface(pl.LightningModule): + def __init__(self, args): + super().__init__() + logger.info("TransNetV2 模型初始化开始...") + self.args = args + self.batch_size = self.args.batch_size + self.learning_rate = self.args.lr + self.model = TransNetV2() + + ## 参数初始化 + for m in self.model.modules(): + if isinstance(m, (nn.Conv2d, nn.Linear)): + nn.init.xavier_uniform_(m.weight) + + ## 使用原始权重初始化 + if self.args.raw_transnet_weights is not None: + checkpoint = torch.load(self.args.raw_transnet_weights) + del checkpoint["cls_layer1.weight"] + del checkpoint["cls_layer1.bias"] + del checkpoint["cls_layer2.weight"] + del checkpoint["cls_layer2.bias"] + self.model.load_state_dict(checkpoint, strict=False) + print("载入原始模型权重") + + logger.info("TransNetV2 模型初始化结束") + + def training_step(self, batch, batch_idx): + frames, one_hot_gt, many_hot_gt = ( + batch["frames"], + batch["one_hot"], + batch["many_hot"], + ) + single_frame_pred, all_frame_pred = self.model(frames) + return single_frame_pred, all_frame_pred, one_hot_gt, many_hot_gt + + def training_step_end(self, output): + ( + single_frame_pred, + all_frame_pred, + one_hot_gt, + many_hot_gt, + ) = output # single_frame_pred维度为[片段数, 100, 3]，one_hot_gt维度为[片段数, 100] + loss_one = F.cross_entropy( + single_frame_pred[:, 15:-15, :].reshape(-1, 2), + one_hot_gt[:, 15:-15].reshape(-1), + weight=torch.tensor([0.15, 0.85], device=single_frame_pred.device).type_as( + single_frame_pred + ), + ) + loss_all = F.cross_entropy( + all_frame_pred[:, 15:-15, :].reshape(-1, 2), + many_hot_gt[:, 15:-15].reshape(-1), + weight=torch.tensor([0.15, 0.85], device=all_frame_pred.device).type_as( + all_frame_pred + ), + ) + loss_total = loss_one * 0.9 + loss_all * 0.1 + + self.log( + "train_loss", + loss_total, + on_epoch=True, + on_step=True, + prog_bar=True, + logger=True, + ) + return loss_total + + def validation_step(self, batch, batch_idx): + frames, one_hot_gt, many_hot_gt = ( + batch["frames"], + batch["one_hot"], + batch["many_hot"], + ) + single_frame_pred, all_frame_pred = self.model(frames) + mp4_ids = batch["mp4_ids"] + + batch_mp4_scenes_index = batch["batch_mp4_scenes_index"] + fps_batch = batch["fps_batch"] + return ( + single_frame_pred, + all_frame_pred, + one_hot_gt, + many_hot_gt, + mp4_ids, + batch_mp4_scenes_index, + fps_batch, + ) + + def validation_step_end(self, output): + ( + single_frame_pred, + all_frame_pred, + one_hot_gt, + many_hot_gt, + mp4_ids, + _, + _, + ) = output + + # loss_one = self.lossfun(single_frame_pred.reshape(-1,3), one_hot_gt.reshape(-1)) + # loss_all = self.lossfun(all_frame_pred.reshape(-1,3), many_hot_gt.reshape(-1)) + loss_one = F.cross_entropy( + single_frame_pred[:, 15:-15, :].reshape(-1, 2), + one_hot_gt[:, 15:-15].reshape(-1), + weight=torch.tensor([0.15, 0.85], device=single_frame_pred.device).type_as( + single_frame_pred + ), + ) + loss_all = F.cross_entropy( + all_frame_pred[:, 15:-15, :].reshape(-1, 2), + many_hot_gt[:, 15:-15].reshape(-1), + weight=torch.tensor([0.15, 0.85], device=single_frame_pred.device).type_as( + single_frame_pred + ), + ) + loss_total = loss_one * 0.8 + loss_all * 0.2 + self.log( + "val_loss", + loss_total, + on_epoch=True, + on_step=True, + prog_bar=True, + logger=True, + ) + + def validation_epoch_end(self, output): + start = time.time() + class_threshold_list = [0.1, 0.3, 0.5, 0.7] + # 计算每个不同的class_threshold下召准 + for class_threshold in class_threshold_list: + transition_label_list = [] + for output_each in output: + ( + single_frame_pred, + all_frame_pred, + one_hot_gt, + many_hot_gt, + mp4_ids, + batch_mp4_scenes_index, + fps_batch, + ) = output_each + transition_label_list = transition_label_list + complete_results_batch( + mp4_ids.cpu(), + batch_mp4_scenes_index.cpu(), + fps_batch.cpu(), + single_frame_pred.cpu().float(), + class_threshold, + ) + custom_indicator = pr_call( + transition_label_list, thresholds=[0.05, 0.1, 0.2, 0.3] + ) + self.log( + f"{class_threshold}_0.01s_P", + custom_indicator[0.05]["precision"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.01s_R", + custom_indicator[0.05]["recall"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.1s_P", + custom_indicator[0.1]["precision"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.1s_R", + custom_indicator[0.1]["recall"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.2s_P", + custom_indicator[0.2]["precision"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.2s_R", + custom_indicator[0.2]["recall"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.3s_P", + custom_indicator[0.3]["precision"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + self.log( + f"{class_threshold}_0.3s_R", + custom_indicator[0.3]["recall"], + on_epoch=True, + on_step=False, + prog_bar=False, + logger=True, + ) + print("推理耗时:{}".format(time.time() - start)) + + ## 优化器配置 + def configure_optimizers(self): + logger.info("configure_optimizers 初始化开始...") + # 选择优化器 + if self.args.optim == "SGD": + optimizer = torch.optim.SGD( + self.parameters(), lr=self.learning_rate, momentum=0.9 + ) + else: + optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate) + + # 选择学习率调度方式 + if self.args.lr_scheduler == "OneCycleLR": + scheduler = torch.optim.lr_scheduler.OneCycleLR( + optimizer, max_lr=0.0002, verbose=True, epochs=500, steps_per_epoch=7 + ) + logger.info("configure_optimizers 初始化结束...") + return [optimizer], [scheduler] + elif self.args.lr_scheduler == "CosineAnnealingLR": + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( + optimizer, T_max=200, eta_min=5e-7, verbose=True, last_epoch=-1 + ) + logger.info("configure_optimizers 初始化结束...") + return [optimizer], [scheduler] + elif self.args.lr_scheduler == "None": + logger.info("configure_optimizers 初始化结束...") + return optimizer diff --git a/MuseV/MMCM/mmcm/vision/transition/TransNetV2/transnetv2_predictor.py b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/transnetv2_predictor.py new file mode 100755 index 0000000000000000000000000000000000000000..fd3048b1a43553559fe1495a86ed73ab73d2ac86 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/transnetv2_predictor.py @@ -0,0 +1,282 @@ +# -*- coding: utf-8 -*- +from typing import Dict, List, Union +import os +import json +import traceback +import argparse +import hashlib + +import librosa +import soundfile as sf +import numpy as np +import torch +from moviepy.editor import * + +from .TransNetmodels import TransNetV2 +from ...video_map.video_meta_info import VideoMetaInfo +from ...video_map.video_map import VideoMap +from ...video_map.video_clip import VideoClipSeq +from ...black_border import det_video_black_border +from ...utils.path_util import get_video_signature +from ...data.video_dataset import MoviepyVideoDataset, SequentialDataset + + +def predict( + model, + video_path, + threshold=0.3, + sample_fps=25, + content_box=None, + single_frame_ratio=1, + map_path: str = None, + ignored_keys: List = None, +) -> VideoMap: + video_hash_code, video_path = get_video_signature(path=video_path, rename=True) + basename = os.path.basename(video_path) + filename, ext = os.path.splitext(video_path) + with torch.no_grad(): + ( + single_frame_result, + all_frame_result, + fps, + total_frames, + duration, + height, + width, + ) = model.predict_video( + video_path, + cache_path="", + c_box=content_box, + width=48, + height=27, + input_frames=10000, + overlap=100, + sample_fps=sample_fps, + ) + # pred_label = single_frame_ratio * single_frame_result + (1 - single_frame_ratio) * all_frame_result + pred_label = np.array([single_frame_result, all_frame_result]) + pred_label = pred_label.max(axis=0) + transition_index = np.where(pred_label > threshold)[0] # 转场帧位置 + transition_index = transition_index.astype(np.float) + # 对返回结果做后处理合并相邻帧 + result_transition = [] + for i, transition in enumerate(transition_index): + if i == 0: + result_transition.append([transition]) + else: + if abs(result_transition[-1][-1] - transition) <= 4: + result_transition[-1].append(transition) + else: + result_transition.append([transition]) + + result = [[0]] + for item in result_transition: + start_idx = int(item[0]) + end_idx = int(item[-1]) + if len(item) > 3: + if max(pred_label[start_idx : end_idx + 1]) > 0.3: + result.append([item[0], item[-1]]) + elif len(item) > 1: + if max(pred_label[start_idx : end_idx + 1]) > 0.4: + result.append([item[0], item[-1]]) + else: + if pred_label[start_idx] > 0.45: + result.append(item) + result.append([pred_label.shape[0]]) + + video_meta_info_dct = { + "video_name": filename, + "video_path": video_path, + "video_file_hash_code": video_hash_code, + "fps": fps, + "frame_num": total_frames, + "duration": duration, + "height": height, + "width": width, + "content_box": content_box, + "sample_fps": sample_fps, + } + video_meta_info = VideoMetaInfo.from_video_path(video_path) + video_meta_info.__dict__.update(video_meta_info_dct) + + video_clipseq = [] + slice_id = 0 + for i in range(len(result) - 1): + if len(result[i]) == 1: + vidoe_clip = { + "time_start": round(result[i][0] / sample_fps, 4), # 开始时间 + "duration": round( + result[i + 1][0] / sample_fps - result[i][0] / sample_fps, + 4, + ), # 片段持续时间 + "frame_start": result[i][0], + "frame_end": result[i + 1][0], + "clipid": slice_id, # 片段序号， + "cliptype": "body", + } + video_clipseq.append(vidoe_clip) + slice_id += 1 + elif len(result[i]) == 2: + vidoe_clip = { + "time_start": round(result[i][0] / sample_fps, 4), # 开始时间 + "duration": round( + result[i][1] / sample_fps - result[i][0] / sample_fps, + 4, + ), # 片段持续时间 + "frame_start": result[i][0], + "frame_end": result[i][1], + "clipid": slice_id, # 片段序号， + "cliptype": "transition", + } + video_clipseq.append(vidoe_clip) + slice_id += 1 + + vidoe_clip = { + "time_start": round(result[i][1] / sample_fps, 4), # 开始时间 + "duration": round( + result[i + 1][0] / sample_fps - result[i][1] / sample_fps, + 4, + ), # 片段持续时间 + "frame_start": result[i][1], + "frame_end": result[i + 1][0], + "clipid": slice_id, # 片段序号， + "cliptype": "body", + } + video_clipseq.append(vidoe_clip) + slice_id += 1 + video_clipseq = VideoClipSeq.from_data(video_clipseq) + video_map = VideoMap(meta_info=video_meta_info, clipseq=video_clipseq) + if map_path is not None: + with open(map_path, "w") as f: + json.dump(video_map.to_dct(ignored_keys=ignored_keys), f, indent=4) + return video_map, single_frame_result, all_frame_result + + +class TransNetV2Predictor(object): + def __init__(self, model_path: str, device: str) -> None: + # 模型初始化和参数载入 + self.model = TransNetV2() + checkpoint = torch.load(model_path) # 载入模型参数 + self.model.load_state_dict( + {k.replace("model.", ""): v for k, v in checkpoint.items()} + ) + # model.load_state_dict(checkpoint['state_dict']) + self.model.eval().to(device) + self.device = device + + def __call__(self, video_path, map_path, content_box) -> Dict: + return predict( + self.model, video_path, map_path=map_path, content_box=content_box + ) + + # TODO: is writing + def predict_video_write( + self, + video_dataset: Union[str, SequentialDataset], + c_box=None, + width=48, + height=27, + input_frames=100, + overlap=30, + sample_fps=30, + threshold=0.3, + drop_last=False, + ): + # check parameters + assert overlap % 2 == 0 + assert input_frames > overlap + + # prepare video_dataset + if isinstance(video_dataset, str): + video_dataset = MoviepyVideoDataset(video_dataset) + step = input_frames - overlap + if ( + video_dataset.step != step + or video_dataset.time_size != input_frames + or video_dataset.drop_last != drop_last + ): + video_dataset.generate_sample_idxs( + time_size=input_frames, step=step, drop_last=drop_last + ) + fps = video_dataset.fps + duration = video_dataset.duration + total_frames = video_dataset.total_frames + w, h = video_dataset.size + + if c_box: + video_dataset.cap.crop(*c_box) + + single_frame_pred_lst, all_frame_pred_lst, index_lst = [], [], [] + for i, batch in enumerate(video_dataset): + data, data_index = batch.data, batch.index + data = data.to(self.device) + # shape: batch dim x video frames x frame height x frame width x RGB (not BGR) channels + single_frame_pred, all_frame_pred = self.forward(data.unsqueeze(0)) # 前向推理 + # single_frame_pred = F.softmax(single_frame_pred, dim=-1) # 获得每一帧对应的类别概率 + # single_frame_pred = torch.argmax(single_frame_pred, dim=-1).reshape(-1) + single_frame_pred = torch.sigmoid(single_frame_pred).reshape(-1) + all_frame_pred = torch.sigmoid(all_frame_pred).reshape(-1) + # single_frame_pred = (single_frame_pred>threshold)*1 + if total_frames > data_index[-1]: + if i == 0: + single_frame_pred_label = single_frame_pred[: -overlap // 2] + all_frame_pred_label = all_frame_pred[: -overlap // 2] + else: + single_frame_pred_label = single_frame_pred[ + overlap // 2 : -overlap // 2 + ] + all_frame_pred_label = all_frame_pred[overlap // 2 : -overlap // 2] + else: + if i == 0: + single_frame_pred_label = single_frame_pred + all_frame_pred_label = all_frame_pred + else: + single_frame_pred_label = single_frame_pred[overlap // 2 :] + all_frame_pred_label = all_frame_pred[overlap // 2 :] + single_frame_pred_lst.append(single_frame_pred_label) + all_frame_pred_lst.append(all_frame_pred_label) + index_lst.extent(data_index) + single_frame_pred_label = torch.concat(single_frame_pred_lst, dim=0) + all_frame_pred_label = torch.concat(all_frame_pred_lst, dim=0) + single_frame_pred_label = single_frame_pred_label.cpu().numpy() + all_frame_pred_label = all_frame_pred_label.cpu().numpy() + + # 对返回结果做后处理合并相邻帧 + pred_label = np.array([single_frame_pred_label, all_frame_pred_label]) + pred_label = pred_label.max(axis=0) + transition_index = np.where(pred_label > threshold)[0] # 转场帧位置 + transition_index = transition_index.astype(np.float) + result_transition = [] + for i, transition in enumerate(transition_index): + if i == 0: + result_transition.append([transition]) + else: + if abs(result_transition[-1][-1] - transition) <= 4: + result_transition[-1].append(transition) + else: + result_transition.append([transition]) + + result = [[0]] + for item in result_transition: + start_idx = int(item[0]) + end_idx = int(item[-1]) + if len(item) > 3: + if max(pred_label[start_idx : end_idx + 1]) > 0.3: + result.append([item[0], item[-1]]) + elif len(item) > 1: + if max(pred_label[start_idx : end_idx + 1]) > 0.4: + result.append([item[0], item[-1]]) + else: + if pred_label[start_idx] > 0.45: + result.append(item) + result.append([pred_label.shape[0]]) + + return ( + single_frame_pred_label, + all_frame_pred_label, + fps, + total_frames, + duration, + h, + w, + ) diff --git a/MuseV/MMCM/mmcm/vision/transition/TransNetV2/utils.py b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/utils.py new file mode 100755 index 0000000000000000000000000000000000000000..667abab55e773f3e1d0ecf682bafa21f18beed52 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/transition/TransNetV2/utils.py @@ -0,0 +1,105 @@ +import os +import pickle +import ffmpeg +import numpy as np +import torch + + +def get_frames(fn, cache_path, start_frame, end_frame, width=48, height=27): + ''' + 先查询cache_path路径下是否有fn的缓存文件(.pkl),若存在则直接载入, 不存在则通过ffmpeg提取获得 + fn: mp4文件所在路径 + width, height: 转换为指定宽高的视频 + cache_path: 缓存文件所在位置, 例如/data_share7/v_hyggewang/视频单帧数据_h48_w27, 该文件夹中包含有mp4_id.pkl文件则会导入该文件 + return: [总帧率, height, width, 3], np.array + ''' + cache_mp4_pkl = os.path.join(cache_path, os.path.basename(fn).replace('mp4','pkl')) + if os.path.exists(cache_mp4_pkl) : + video = pickle.load(open(cache_mp4_pkl,'rb')) + assert (video.shape[1]==height and video.shape[2]==width), "mp4缓存文件维度与指定h,w不同" +# print('mp4帧文件缓存载入成功') + else: +# print('使用ffmpeg提取mp4单帧图片数据') + # 视频转化为np数组 + video_stream, err = ( + ffmpeg + .input(fn) + # .filter('select', 'between(n,{},{})'.format(start_frame,end_frame)) + .trim(start_frame=start_frame, end_frame=end_frame) + .setpts('PTS-STARTPTS') + .output('pipe:', format='rawvideo', pix_fmt='rgb24', s='{}x{}'.format(width, height)) + .run(capture_stdout=True, capture_stderr=True) + ) + video = np.frombuffer(video_stream, np.uint8).reshape([-1, height, width, 3]) + return video + +def get_frames_label(mp4_annotations, n_frames, fps): + ''' + 根据mp4的标注信息,以及总帧数长度,给所有帧打标签。 + mp4_annotations: 列表[item...], 每个item是一个字典, 包括有该时间点类别，具体时间。 + fps: 该视频的帧率 + n_frames: 该视频总帧数 + return: many_hot,one_hot维度为(n_frames,)。one_hot表示只有在标注帧的地方是有标签, many_hot表示标注帧的地方前后2帧有相同标签 + ''' + one_hot = np.zeros([n_frames], np.int64) + many_hot = np.zeros([n_frames], np.int64) + for item in mp4_annotations: + if item["class"] == "transition": + transition_frame_idx = int(item['timaestamp'] * fps) # 根据据标注时间点标注关键帧标签 + one_hot[min(transition_frame_idx, n_frames-1)] = 1 # 卡点帧标记为1 ,有些标注视频总长度低于标注点位，因此需要处理一下 + for i in range(min(transition_frame_idx-2, n_frames-2), min(transition_frame_idx+2, n_frames)): + many_hot[i] = 1 # 卡点帧周围2帧标记为1(共5帧) + return one_hot, many_hot + +def get_mp4_scenes(frames, one_hot, many_hot): + """ + 对视频按照100帧顺序切片,单个视频顺序切出多段,并且每个片段重叠30帧,例如: 210帧总长度,需要切成0-100帧,70-170帧,140-240帧(重复30帧) + frames: (T, H, W, 通道数),视频单帧数据.(np.array) + one_hot: 视频标签one_hot + many_hot: 视频标签many_hot + return: 按100帧切割的图片块:[x, 100, H, W, 3], one_hot_scenes:[x, 100], many_hot_scenes:[x, 100], x:表示该mp4被切成了多少块 + """ + frames = torch.from_numpy(frames) + + # 重复最后一帧图片使得图片能够正好按规则切分 + if (len(frames)-30)%70 != 0: + repeat_n = (len(frames)-30)//70*70 + 100 - len(frames) + last_scenes = frames[-1, :, :, :] # 获取最后一个图像 + last_scenes = torch.unsqueeze(last_scenes, 0).expand([repeat_n, -1, -1, -1]) + frames = torch.cat([frames, last_scenes], dim=0) # 在原数据最后增加几帧图片 + one_hot = np.concatenate((one_hot, [0]*repeat_n)) # 标签也需要增加长度 + many_hot = np.concatenate((many_hot, [0]*repeat_n)) + + one_hot = torch.from_numpy(one_hot) # 转化为tensor + many_hot = torch.from_numpy(many_hot) + + scenes = [] # 用于储存分割的片段 + one_hot_scenes = [] # 用于储存分割片段的label + many_hot_scenes = [] + # 按规则切片 + for i in range((len(frames)-30)//70): + scenes.append(frames[i*70:(i*70+100)]) + one_hot_scenes.append(one_hot[i*70:(i*70+100)]) + many_hot_scenes.append(many_hot[i*70:(i*70+100)]) + return torch.stack(scenes, dim=0), torch.stack(one_hot_scenes, dim=0), torch.stack(many_hot_scenes, dim=0), int((len(frames)-30)//70) + +def get_mp4_random_scenes(frames, one_hot, many_hot): + """ + 对视频随机设定起点, 抽取100帧数据 + frames: (T, H, W, 通道数),视频单帧数据.(np.array) + one_hot: 视频标签one_hot + many_hot: 视频标签many_hot + return: 随机起点的100帧图片数据[1, 100, H, W, 3], one_hot_scenes:[1, 100], many_hot_scenes:[1, 100] + """ + number_frames = len(frames) + start_frames = np.random.randint(0, number_frames-100+1) # 随机获得起始帧位置 + end_frames = start_frames + 100 # 获得终止帧位置 + + fal_frames = torch.from_numpy(frames[start_frames:end_frames]) + fal_one_hot = torch.from_numpy(one_hot[start_frames:end_frames]) + fal_many_hot = torch.from_numpy(many_hot[start_frames:end_frames]) + return torch.stack([fal_frames], dim=0), torch.stack([fal_one_hot], dim=0), torch.stack([fal_many_hot], dim=0) + + + + diff --git a/MuseV/MMCM/mmcm/vision/transition/__init__.py b/MuseV/MMCM/mmcm/vision/transition/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/transition/scene_transition_predictor.py b/MuseV/MMCM/mmcm/vision/transition/scene_transition_predictor.py new file mode 100755 index 0000000000000000000000000000000000000000..e127bcab827aadf812850a0fec952eda1830d891 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/transition/scene_transition_predictor.py @@ -0,0 +1,483 @@ +from __future__ import print_function + +import traceback +from typing import Dict +from moviepy.editor import VideoFileClip +import hashlib +import json +import numpy as np +import os +import time +import copy +import os.path as osp + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torchvision import transforms +import librosa + +from ...utils.util import load_dct_from_file + +# from lgss.utilis.package import * + +normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + +transformer = transforms.Compose( + [ + # transforms.Resize(256), + # transforms.CenterCrop(224), + transforms.ToTensor(), + normalizer, + ] +) + + +def wav2stft(data): + # normalize + mean = (data.max() + data.min()) / 2 + span = (data.max() - data.min()) / 2 + if span < 1e-6: + span = 1 + data = (data - mean) / span # range: [-1,1] + + D = librosa.core.stft(data, n_fft=512) + freq = np.abs(D) + freq = librosa.core.amplitude_to_db(freq) + span = 80 + thr = 4 * span + + if freq.shape[1] <= thr: + copy_ = freq.copy() + while freq.shape[1] < thr: + tmp = copy_.copy() + freq = np.concatenate((freq, tmp), axis=1) + freq = freq[:, :thr] + else: + # sample + n = freq.shape[1] + stft_img = [] + stft_img.append(freq[:, : 2 * span]) + # stft_img.append(freq[:, n//2 - span : n//2 + span]) + stft_img.append(freq[:, -2 * span :]) + freq = np.concatenate(stft_img, axis=1) + return freq + + +def test( + model, + data_place, + data_cast=None, + data_act=None, + data_aud=None, + last_image_overlap_feat=None, + last_aud_overlap_feat=None, +): + with torch.no_grad(): + # data_place = data_place.cuda() if data_place is not None else [] + data_cast = data_cast.cuda() if data_cast is not None else [] + data_act = data_act.cuda() if data_act is not None else [] + data_aud = data_aud.cuda() if data_aud is not None else [] + ( + img_output, + aud_output, + image_overlap_feat, + audio_overlap_feat, + shot_dynamic_list, + ) = model( + data_place, + data_cast, + data_act, + data_aud, + last_image_overlap_feat, + last_aud_overlap_feat, + ) + img_output = img_output.view(-1, 2) + img_output = F.softmax(img_output, dim=1) + img_prob = img_output[:, 1] + img_prob = img_prob.cpu() + aud_output = aud_output.view(-1, 2) + aud_output = F.softmax(aud_output, dim=1) + aud_prob = aud_output[:, 1] + aud_prob = aud_prob.cpu() + return img_prob, aud_prob, image_overlap_feat, audio_overlap_feat, shot_dynamic_list + + +def predict( + model, + cfg, + video_path, + save_path, + map_path, + seq_len=120, + shot_num=4, + overlap=21, + shot_frame_max_num=60, +): + assert overlap % 2 == 1 + video_name = ".".join(video_path.split("/")[-1].split(".")[:-1]) + if not os.path.exists(save_path): + os.makedirs(save_path) + # video_hash_code = (os.popen('md5sum {}'.format(video_path))).readlines()[0].split(' ')[0] + with open(video_path, "rb") as fd: + data = fd.read() + video_hash_code = hashlib.md5(data).hexdigest() + save_path = os.path.join( + save_path, "{}_{}.json".format(video_name, video_hash_code[:8]) + ) + if os.path.exists(save_path) and not args.overwrite: + video_map = json.load(open(save_path), encoding="UTF-8") + valid_clips = [] + for clip in video_map["clips"]: + if clip["cliptype"] == "body" and clip["duration"] > 0.25: + valid_clips.append(clip) + # Capture video + if ( + video_map["content_box"][2] - video_map["content_box"][0] + > video_map["content_box"][3] - video_map["content_box"][1] + ): + target_resolution = ( + 256 + * video_map["height"] + / (video_map["content_box"][3] - video_map["content_box"][1]), + None, + ) + else: + target_resolution = ( + None, + 256 + * video_map["width"] + / (video_map["content_box"][2] - video_map["content_box"][0]), + ) + video = VideoFileClip( + video_path, + target_resolution=target_resolution, + resize_algorithm="bilinear", + audio_fps=16000, + ) + # video = video.crop(*video_map["content_box"]) + x1 = video_map["content_box"][0] * video.size[0] // video_map["width"] + y1 = video_map["content_box"][1] * video.size[1] // video_map["height"] + x2 = video_map["content_box"][2] * video.size[0] // video_map["width"] + y2 = video_map["content_box"][3] * video.size[1] // video_map["height"] + video = video.crop( + width=(x2 - x1) * 224 / 256, + height=224, + x_center=(x1 + x2) // 2, + y_center=(y1 + y2) // 2, + ) + print("exists " + save_path) + else: + map_path = os.path.join( + map_path, "{}_{}.json".format(video_name, video_hash_code[:8]) + ) + if not os.path.exists(map_path): + print("map not exist: ", map_path) + return + + video_map = json.load(open(map_path), encoding="UTF-8") + assert video_hash_code == video_map["video_file_hash_code"] + + # Capture video + if ( + video_map["content_box"][2] - video_map["content_box"][0] + > video_map["content_box"][3] - video_map["content_box"][1] + ): + target_resolution = ( + 256 + * video_map["height"] + / (video_map["content_box"][3] - video_map["content_box"][1]), + None, + ) + else: + target_resolution = ( + None, + 256 + * video_map["width"] + / (video_map["content_box"][2] - video_map["content_box"][0]), + ) + video = VideoFileClip( + video_path, + target_resolution=target_resolution, + resize_algorithm="bilinear", + audio_fps=16000, + ) + # video = video.crop(*video_map["content_box"]) + x1 = video_map["content_box"][0] * video.size[0] // video_map["width"] + y1 = video_map["content_box"][1] * video.size[1] // video_map["height"] + x2 = video_map["content_box"][2] * video.size[0] // video_map["width"] + y2 = video_map["content_box"][3] * video.size[1] // video_map["height"] + video = video.crop( + width=(x2 - x1) * 224 / 256, + height=224, + x_center=(x1 + x2) // 2, + y_center=(y1 + y2) // 2, + ) + fps = video.fps + duration = video.duration + total_frames = int(duration * fps) + width, height = video.size + print("fps, frame_count, width, height:", fps, total_frames, width, height) + + valid_clips = [] + for clip in video_map["clips"]: + if clip["cliptype"] == "body" and clip["duration"] > 0.25: + valid_clips.append(clip) + # valid_clips = valid_clips[:150] + total_shot_num = len(valid_clips) + last_image_overlap_feat = None + last_aud_overlap_feat = None + truncate_time = 0.1 + all_shot_dynamic_list = [] + for i in range(total_shot_num // (seq_len - overlap) + 1): + shot_frame_list = [] + shot_audio_list = [] + start_shot = i * (seq_len - overlap) + end_shot = min(start_shot + seq_len, total_shot_num) + if i != 0: + start_shot += overlap + print(start_shot, end_shot) + if start_shot >= end_shot: + break + for clip in valid_clips[start_shot:end_shot]: + time_start = clip["time_start"] + time_end = clip["time_start"] + clip["duration"] + truncate_time = min(clip["duration"] / 10, 0.1) + time_start += truncate_time + time_end -= truncate_time + time_start = max(time_start, (time_end + time_start) / 2 - 3) + time_end = min(time_end, (time_end + time_start) / 2 + 3) + duration = time_end - time_start + t0 = time.time() + video_subclip = video.subclip(time_start, time_end) + # video_save_path = os.path.join(args.video_save_path, 'shot_{:04d}.mp4'.format(clip["clipid"])) + # video_subclip.write_videofile(video_save_path, threads=8, codec='libx264') + if "image" in cfg.dataset["mode"]: + frame_iter = video_subclip.iter_frames(fps=10) + shot_frame = [] + for frame in frame_iter: + frame = transformer(frame) + shot_frame.append(frame) + if len(shot_frame) > shot_frame_max_num: + break + shot_frame = torch.stack(shot_frame) + shot_frame = shot_frame.cuda() + shot_frame_list.append(shot_frame) + + t5 = time.time() + if "aud" in cfg.dataset["mode"]: + try: + sub_audio = video.audio.subclip( + clip["time_start"], clip["time_start"] + clip["duration"] + ) + sub_audio = sub_audio.to_soundarray( + fps=16000, quantize=True, buffersize=20000 + ) + sub_audio = sub_audio.mean(axis=1) + except: + sub_audio = np.zeros((16000 * 4), np.float32) + sub_audio = wav2stft(sub_audio) + sub_audio = torch.from_numpy(sub_audio).float() + sub_audio = sub_audio.unsqueeze(dim=0) + shot_audio_list.append(sub_audio) + t6 = time.time() + print(clip["clipid"], t5 - t0, t6 - t5) + + data_place = data_aud = None + if len(shot_frame_list) > 0: + # data_place = torch.stack(shot_frame_list) + data_place = shot_frame_list + if len(shot_audio_list) > 0: + data_aud = torch.stack(shot_audio_list) + data_aud = data_aud.unsqueeze(dim=0) + ( + img_preds, + aud_preds, + last_image_overlap_feat, + last_aud_overlap_feat, + shot_dynamic_list, + ) = test( + model, + data_place=data_place, + data_aud=data_aud, + last_image_overlap_feat=last_image_overlap_feat, + last_aud_overlap_feat=last_aud_overlap_feat, + ) + print(shot_dynamic_list) + all_shot_dynamic_list.extend(shot_dynamic_list) + if total_shot_num > end_shot: + if i == 0: + img_preds_all = img_preds[: -(overlap - shot_num + 1) // 2] + aud_preds_all = aud_preds[: -(overlap - shot_num + 1) // 2] + else: + img_preds_all = torch.cat( + ( + img_preds_all, + img_preds[ + (overlap - shot_num + 1) + // 2 : -(overlap - shot_num + 1) + // 2 + ], + ), + dim=0, + ) + aud_preds_all = torch.cat( + ( + aud_preds_all, + aud_preds[ + (overlap - shot_num + 1) + // 2 : -(overlap - shot_num + 1) + // 2 + ], + ), + dim=0, + ) + else: + if i == 0: + img_preds_all = img_preds + aud_preds_all = aud_preds + else: + img_preds_all = torch.cat( + (img_preds_all, img_preds[(overlap - shot_num + 1) // 2 :]), + dim=0, + ) + aud_preds_all = torch.cat( + (aud_preds_all, aud_preds[(overlap - shot_num + 1) // 2 :]), + dim=0, + ) + + print( + img_preds_all.shape[0], + total_shot_num - shot_num + 1, + len(all_shot_dynamic_list), + ) + assert img_preds_all.shape[0] == total_shot_num - shot_num + 1 + assert len(all_shot_dynamic_list) == total_shot_num + print("img_preds_all: ", img_preds_all) + print("aud_preds_all: ", aud_preds_all) + video_map["scenes_img_preds"] = img_preds_all.tolist() + video_map["scenes_aud_preds"] = aud_preds_all.tolist() + for clip, dynamic in zip(valid_clips, all_shot_dynamic_list): + clip["dynamic"] = None + if dynamic is not None: + clip["dynamic"] = round(np.clip(dynamic, 0, 1), 5) + + preds_all = cfg.model.ratio[0] * np.array( + video_map["scenes_img_preds"] + ) + cfg.model.ratio[3] * np.array(video_map["scenes_aud_preds"]) + video_map["scenes_preds"] = preds_all.tolist() + scene_boundary = np.where(preds_all > args.threshold)[0] + video_map["scenes"] = [] + scene = { + "sceneid": 0, + "clip_start": valid_clips[0]["clipid"], + "clip_end": valid_clips[0]["clipid"], + "time_start": valid_clips[0]["time_start"], + "time_end": valid_clips[0]["time_start"] + valid_clips[0]["duration"], + } + for i in scene_boundary: + scene["clip_end"] = valid_clips[i + shot_num // 2 - 1]["clipid"] + scene["time_end"] = ( + valid_clips[i + shot_num // 2 - 1]["time_start"] + + valid_clips[i + shot_num // 2 - 1]["duration"] + ) + scene["roles"] = {} + scene["dynamic"] = None + dynamic_num = 0 + dynamic = 0 + for clip in video_map["clips"][scene["clip_start"] : scene["clip_end"] + 1]: + for roleid in clip["roles"].keys(): + if roleid not in scene["roles"]: + scene["roles"][roleid] = { + "name": clip["roles"][roleid]["name"] + if "name" in clip["roles"][roleid] + else "" + } + if "dynamic" in clip and clip["dynamic"] != None: + dynamic += clip["dynamic"] + dynamic_num += 1 + if dynamic_num > 0: + scene["dynamic"] = dynamic / dynamic_num + for clip in video_map["clips"][scene["clip_start"] : scene["clip_end"] + 1]: + clip["scene_roles"] = scene["roles"] + clip["scene_dynamic"] = scene["dynamic"] + clip["sceneid"] = scene["sceneid"] + video_map["scenes"].append(copy.deepcopy(scene)) + scene["sceneid"] += 1 + scene["clip_start"] = scene["clip_end"] = valid_clips[i + shot_num // 2][ + "clipid" + ] + scene["time_start"] = valid_clips[i + shot_num // 2]["time_start"] + scene["time_end"] = ( + valid_clips[i + shot_num // 2]["time_start"] + + valid_clips[i + shot_num // 2]["duration"] + ) + scene["clip_end"] = valid_clips[-1]["clipid"] + scene["time_end"] = valid_clips[-1]["time_start"] + valid_clips[-1]["duration"] + scene["roles"] = {} + scene["dynamic"] = None + dynamic_num = 0 + dynamic = 0 + for clip in video_map["clips"][scene["clip_start"] : scene["clip_end"] + 1]: + for roleid in clip["roles"].keys(): + if roleid not in scene["roles"]: + scene["roles"][roleid] = { + "name": clip["roles"][roleid]["name"] + if "name" in clip["roles"][roleid] + else "" + } + if "dynamic" in clip and clip["dynamic"] != None: + dynamic += clip["dynamic"] + dynamic_num += 1 + if dynamic_num > 0: + scene["dynamic"] = dynamic / dynamic_num + for clip in video_map["clips"][scene["clip_start"] : scene["clip_end"] + 1]: + clip["scene_roles"] = scene["roles"] + clip["scene_dynamic"] = scene["dynamic"] + clip["sceneid"] = scene["sceneid"] + video_map["scenes"].append(scene) + return video_map + + +class SceneTransitionPredictor(object): + def __init__(self, config_path, overlap=41, model_path=None) -> None: + from mmcv import Config + from lgss.utilis import load_checkpoint + import lgss.src.models as models + + self.config_path = config_path + cfg = Config.fromfile(config_path) + # cfg = load_dct_from_file(config_path) + self.cfg = cfg + self.model = models.__dict__[cfg.model.name](cfg, overlap).cuda() + self.model = nn.DataParallel(self.model) + checkpoint = load_checkpoint( + osp.join(cfg.logger.logs_dir, "model_best.pth.tar") + ) + paras = {} + for key, value in checkpoint["state_dict"].items(): + if key in self.model.state_dict(): + paras[key] = value + if "aud" in cfg.dataset["mode"]: + c_logs_dir = cfg.logger.logs_dir.replace("image50", "aud") + checkpoint = load_checkpoint(osp.join(c_logs_dir, "model_best.pth.tar")) + for key, value in checkpoint["state_dict"].items(): + if key in self.model.state_dict(): + paras[key] = value + print(list(paras.keys())) + self.model.load_state_dict(paras) + self.model.eval() + + def __call__( + self, + video_path, + video_map, + ) -> Dict: + video_info = predict( + self.model, + self.cfg, + video_path, + video_map, + overlap=self.overlap, + ) + return video_info diff --git a/MuseV/MMCM/mmcm/vision/utils/__init__.py b/MuseV/MMCM/mmcm/vision/utils/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/utils/data_type_util.py b/MuseV/MMCM/mmcm/vision/utils/data_type_util.py new file mode 100755 index 0000000000000000000000000000000000000000..333dff46761fd55a6b85809b106ebe21c12896c5 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/utils/data_type_util.py @@ -0,0 +1,148 @@ +import os +from typing import List, Literal, Tuple, Union +import cv2 +from einops import rearrange, repeat + +import numpy as np +from PIL import Image +import torch + + +def convert_images( + data: Union[ + str, List[str], Image.Image, List[Image.Image], np.ndarray, torch.Tensor + ], + return_type: str = "numpy", + data_channel_order: str = "b h w c", + input_rgb_order: str = "rgb", + return_rgb_order: str = "rgb", + return_data_channel_order: str = "b h w c", +) -> Union[np.ndarray, List[Image.Image], torch.Tensor]: + """将所有图像数据都先转换成numpy b*c*h*w格式，再根据return_type转换成目标格式。 + Args: + data (Union[str, List[str], Image.Image, List[Image.Image], np.ndarray]): _description_ + return_type (str, optional): 返回的图像格式. Defaults to "numpy". 候选项 + numpy + torch + pil + opencv + rgb_order (str, optional): 输入图像的通道格式, 默认是"rgb" 格式，候选项 + rgb + bgr + Raises: + ValueError: only support return_type (numpy, torch, pil), but given return_type + + Returns: + Union[np.ndarray, List[Image.Image], torch.Tensor]: _description_ + """ + + if isinstance(data, torch.Tensor): + data = data.cpu().numpy() + + if isinstance(data, (str, Image.Image)): + data = [data] + if isinstance(data, list): + if isinstance(data[0], str): + data = [Image.open(image) for image in data] + if data_channel_order == "rgb": + data = [image.convert("RGB") for image in data] + if isinstance(data[0], Image.Image): + data = [np.asarray(image) for image in data] + if isinstance(data[0], np.ndarray): + data = np.stack(data) + + if isinstance(data, np.ndarray): + if data.ndim == 5: + data = rearrange(data, "{}-> (b t) h w c".format(data_channel_order)) + elif data.ndim == 4: + if data_channel_order != "b h w c": + data = rearrange(data, "{}-> b h w c".format(data_channel_order)) + elif data.ndim == 3: + if data_channel_order != "h w c": + data = rearrange(data, "{}-> h w c".format(data_channel_order)) + data = data[np.newaxis, ...] + if input_rgb_order != return_rgb_order: + data = data[..., ::-1] + if return_data_channel_order != "b h w c": + data = rearrange(data, "b h w c -> {}".format(return_data_channel_order)) + c_idx = return_data_channel_order.split(" ").index("c") + if return_type == "numpy": + return data + elif return_type == "torch": + return torch.from_numpy(data) + elif return_type.lower() == "pil": + data = data.astype(np.uint8) + data = [Image.fromarray(data[i]) for i in range(len(data))] + return data + elif return_type == "opencv": + data = data.transpose(0, 2, 3, 1) + return data + else: + raise ValueError( + f"only support return_type (numpy, torch, PIL), but given {return_type}" + ) + + +def is_video(path: str, exts=["mp4", "mkv", "ts", "rmvb", "mov", "avi"]): + path_ext = os.path.splitext(os.path.basename(path))[-1][1:].lower() + return path_ext in exts + + +def pil_read_image_with_alpha( + img_path: str, + color_channel: str = "rgb", + return_type: Literal["numpy", "PIL"] = "PIL", +) -> Tuple[Image.Image, np.ndarray]: + image_with_alpha = Image.open(img_path) + if image_with_alpha.mode != "RGBA": + image_with_alpha = image_with_alpha.convert("RGBA") + background = Image.new("RGB", image_with_alpha.size, (255, 255, 255)) + if background.mode != "RGBA": + background = background.convert("RGBA") + rgb_image = Image.alpha_composite(background, image_with_alpha) + if color_channel == "rgb": + rgb_image = rgb_image.convert("RGB") + if return_type == "numpy": + rgb_image = np.array(rgb_image) + return rgb_image + + +# 该部分代码不是很正常，可以使用PIL.Image.Image +def opencv_cvt_alpha(image: np.ndarray) -> np.ndarray: + """read image with alpha channel, and fill alpha channel with white background. + + Args: + img (str): opencv read image with alpha channel + Returns: + np.ndarray: image array + """ + # make mask of where the transparent bits are + trans_mask = image[:, :, 3] == 0 + + # replace areas of transparency with white and not transparent + image[trans_mask] = [255, 255, 255, 255] + + # new image without alpha channel... + new_image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR) + + return new_image + + +def read_image_with_alpha(path: str, color_channel: str = "rgb") -> np.ndarray: + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) + if img.shape[2] == 4: + img = opencv_cvt_alpha(img) + if color_channel == "rgb": + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) + return img + + +def read_image_as_5d(path: str, color_channel: str = "rgb") -> np.ndarray: + img = pil_read_image_with_alpha(path, color_channel, return_type="numpy") + img = repeat(img, "h w c-> b c t h w", b=1, t=1) + return img + + +def is_image(path: str, exts=["jpg", "png", "jpeg", "webp"]): + path_ext = os.path.splitext(os.path.basename(path))[-1][1:].lower() + return path_ext in exts diff --git a/MuseV/MMCM/mmcm/vision/utils/path_util.py b/MuseV/MMCM/mmcm/vision/utils/path_util.py new file mode 100755 index 0000000000000000000000000000000000000000..9873059491f28792dc15f5fe0851230b9a9a1a86 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/utils/path_util.py @@ -0,0 +1,107 @@ +from functools import partial +import os +from typing import Tuple, Union + +from ...utils.path_util import get_dir_file_map, get_path_dct +from ...utils.signature import get_md5sum + + +def get_video_signature( + path: str, + rename: bool = False, + length: int = None, + signature: str = None, + sep: str = "@", +) -> Union[str, Tuple[str, str]]: + """视频文件hash值特殊保存方法，name@signature，若hash值与目标长度不符或者不存在，则重新计算，并根据需要是否修改名字 + + Args: + path (str): 视频源路径 + rename (bool, optional): 是否对视频源文件重命名. Defaults to False. + length (int, optional): hash值签名长度. Defaults to 8. + signature (str, optional): full signature of path, to avoid recalculate signature. Defaults to `None`. + sep (str, optional): 将hash值嵌入命名的分隔符. Defaults to "@". + + Returns: + str: 视频文件hash值 + Tuple[str, str]: 对应的hash签名, 新的视频文件地址， + """ + dirname = os.path.dirname(path) + basename = os.path.basename(path) + filename, ext = os.path.splitext(basename) + file_signature = None + if "@" in filename: + file_signature = filename.split(sep)[-1] + if length is not None and len(file_signature) != length: + file_signature = None + if file_signature is None: + if signature is None: + signature = get_md5sum(path, length=length) + file_signature = signature + if rename: + dst_path = os.path.join( + dirname, "{}@{}{}".format(filename.split(sep)[0], signature, ext) + ) + os.rename(path, dst_path) + path = dst_path + if rename: + return file_signature, path + else: + return file_signature + + +def split_names_with_signature(basename: str, sep: str = "@") -> str: + """从videoinfo中分离 video的名字,videoinfo的名字是videoname_hash.json + + Args: + basename (str): like name_hash + sep (str): like sep + + Returns: + str: 视频文件名 + """ + filename = ".".join(basename.split(".")[:-1]) + ext = basename.split(".")[-1] + if sep in filename: + filename = sep.join(filename.split(sep)[:-1]) + return filename, ext + + +def get_video_map_path_dct( + path: str, mode: int = 1, sep: str = "@", exts=["json"] +) -> dict: + """遍历目标文件夹及子文件夹下所有视频谱面文件，生成字典。""" + dct = get_path_dct( + path=path, + mode=mode, + sep=sep, + split_func=partial(split_names_with_signature, sep=sep), + exts=exts, + ) + return dct + + +def get_video_path_dct( + path, mode: int = 1, sep: str = "@", exts=["mp4", "mkv", "ts", "rmvb", "mov"] +) -> dict: + """遍历目标文件夹及子文件夹下所有视频文件，生成字典。""" + dct = get_path_dct( + path=path, + mode=mode, + sep=sep, + split_func=partial(split_names_with_signature, sep=sep), + exts=exts, + ) + return dct + + +def get_video_emd_path_dct(path, mode: int = 1, sep: str = "@", exts=["hdf5"]) -> dict: + """遍历目标文件夹及子文件夹下所有视频文件，生成字典。""" + dct = get_path_dct( + path=path, + mode=mode, + sep=sep, + split_func=partial(split_names_with_signature, sep=sep), + exts=exts, + ) + return dct diff --git a/MuseV/MMCM/mmcm/vision/utils/torch_util.py b/MuseV/MMCM/mmcm/vision/utils/torch_util.py new file mode 100755 index 0000000000000000000000000000000000000000..2131e767f7b5db12870292467f18ee773a5aa01b --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/utils/torch_util.py @@ -0,0 +1,19 @@ +import torch + + +def find_outlier(grid: torch.Tensor) -> torch.Tensor: + """find outlier coordinary out of grid + + Args: + grid (torch.Tensor): Bx2xHxW + + Returns: + mask: ndarray, BxHxW, 1 for coordinary in grid, 0 for outlier + """ + b, _, h, w = grid.shape + mask = torch.ones((b, h, w)) + outlier_x_coordinary = (grid[:,0,:,:] >= w).nonzero(as_tuple=True) + outlier_y_coordinary = (grid[:,1,:,:] >= h).nonzero(as_tuple=True) + mask[outlier_x_coordinary] = 0 + mask[outlier_y_coordinary] = 0 + return mask diff --git a/MuseV/MMCM/mmcm/vision/utils/vision_util.py b/MuseV/MMCM/mmcm/vision/utils/vision_util.py new file mode 100755 index 0000000000000000000000000000000000000000..92c43de7c9cb06aeac1653252b3e3776a0e9b674 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/utils/vision_util.py @@ -0,0 +1,177 @@ +import math +from typing import Union, Tuple + + +from numpy import ndarray +import numpy as np + + +def cal_start_end_point(big: float, small: float, center: float = None): + if center is None: + center = big / 2 + if center < small / 2: + center = small / 2 + if center > (big - small / 2): + center = big - small / 2 + start = center - small / 2 + end = center + small / 2 + return (start, end) + + +def cal_small_bbox_coord_of_big_bbox( + bigbbox_width, + bigbbox_height, + smallbbox_width, + smallbbox_height, + center_width: float = None, + center_height: float = None, + need_round2even=False, +): + """只有宽高信息，按中心crop计算小矩形在大矩形的剪辑坐标 + + Args: + bigbbox_width (float): _description_ + bigbbox_height (float): _description_ + smallbbox_width (float): _description_ + smallbbox_height (float): _description_ + + Returns: + (float, float, float, float): (x1, y1, x2, y2) 在大矩形中的剪辑位置 + """ + x1, x2 = cal_start_end_point(bigbbox_width, smallbbox_width, center=center_width) + y1, y2 = cal_start_end_point(bigbbox_height, smallbbox_height, center=center_height) + # x1 = (bigbbox_width - smallbbox_width) / 2 + # y1 = (bigbbox_height - smallbbox_height) / 2 + # x2 = (bigbbox_width + smallbbox_width) / 2 + # y2 = (bigbbox_height + smallbbox_height) / 2 + if need_round2even: + x1, y1, x2, y2 = round_up_coord_to_even(x1, y1, x2, y2) + return (x1, y1, x2, y2) + + +def round_up_to_even(num): + return math.floor(num / 2.0) * 2 + + +def round_up_coord_to_even(x1, y1, x2, y2): + x2 = x1 + round_up_to_even(x2 - x1) + y2 = y1 + round_up_to_even(y2 - y1) + return (x1, y1, x2, y2) + + +def cal_crop_coord( + width, + height, + target_width_height_ratio, + restricted_bbox=None, + need_round2even=False, +): + """ + (TODO): 当前只考虑crop，不考虑补全； + (TODO): 当前只考虑视频尺寸比目标尺寸大 + + Args: + width (float): 原视频的宽 + height (float): 原视频的高 + target_width (float): 目标视频的宽 + target_height (float): 目标视频的高 + restricted_bbox ((float, float, float, float), optional): (x1, y1, x2, y2). Defaults to None. + + Returns: + (float, float, float, float): (x1, y1, x2, y2) 在原视频中的剪辑位置 + """ + + if restricted_bbox is None: + target_width, target_height = cal_target_width_height_by_ratio( + width=width, + height=height, + target_width_height_ratio=target_width_height_ratio, + ) + crop_bbox = cal_small_bbox_coord_of_big_bbox( + width, height, target_width, target_height + ) + else: + r_width = restricted_bbox[2] - restricted_bbox[0] + r_height = restricted_bbox[3] - restricted_bbox[1] + target_width, target_height = cal_target_width_height_by_ratio( + width=r_width, + height=r_height, + target_width_height_ratio=target_width_height_ratio, + ) + crop_bbox = cal_small_bbox_coord_of_big_bbox( + r_width, r_height, target_width, target_height + ) + crop_bbox = ( + crop_bbox[0] + restricted_bbox[0], + crop_bbox[1] + restricted_bbox[1], + crop_bbox[2] + restricted_bbox[0], + crop_bbox[3] + restricted_bbox[1], + ) + if need_round2even: + crop_bbox = round_up_coord_to_even(*crop_bbox) + return crop_bbox + + +def cal_target_width_height_by_ratio( + width, height, target_width_height_ratio, need_round2even=False +): + """针对原视频的宽、高和目标视频宽高比，计算合适的宽、高 + + Args: + width (float): 原视频的宽 + height (float): 原视频的高 + target_width_height_ratio (float): 目标视频宽高比 + + Returns: + target_width (float)): 目标宽 + target_height (float): 目标高 + """ + width_height_ratio = width / height + if width_height_ratio >= target_width_height_ratio: + target_width = height * target_width_height_ratio + target_height = height + else: + target_width = width + target_height = width / target_width_height_ratio + if need_round2even: + target_height = round_up_to_even(target_height) + target_width = round_up_to_even(target_width) + return target_width, target_height + + +def cal_target_width_height( + target_width=None, + target_height=None, + target_width_height_ratio=None, + need_even=True, +): + if target_width and not target_height and target_width_height_ratio: + target_height = int(target_width / target_width_height_ratio) + if need_even: + target_height = round_up_to_even(target_height) + if target_height and not target_width and target_width_height_ratio: + target_width = int(target_height * target_width_height_ratio) + if need_even: + target_width = round_up_to_even(target_width) + if target_height and target_width: + target_width_height_ratio = target_width / target_height + return target_width, target_height, target_width_height_ratio + + +def find_outlier(grid: ndarray) -> ndarray: + """find outlier coordinary out of grid + + Args: + grid (ndarray): 2xHxW + + Returns: + mask: ndarray, HxW, 1 for coordinary in grid, 0 for outlier + """ + c, h, w = grid.shape + mask = np.zeros((h, w)) + for i, j in zip(range(h), range(w)): + x = int(grid[0, i, j]) + y = int(grid[1, i, j]) + if x < h and y < w: + mask[x, y] = 1 + return mask diff --git a/MuseV/MMCM/mmcm/vision/video_map/__init__.py b/MuseV/MMCM/mmcm/vision/video_map/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/video_map/clip_process.py b/MuseV/MMCM/mmcm/vision/video_map/clip_process.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/MuseV/MMCM/mmcm/vision/video_map/face.py b/MuseV/MMCM/mmcm/vision/video_map/face.py new file mode 100755 index 0000000000000000000000000000000000000000..b6a345b8f95a3a1668445a5d87ea5447b55abccf --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/face.py @@ -0,0 +1,177 @@ +import os +from typing import Dict, List + +from ...utils.path_util import get_file_name_ext +from ...utils.util import load_dct_from_file +from .vision_object import Object +from .vision_frame import Frame, FrameSeq + + +def face_meta_2_tme_meta(src: dict) -> dict: + """人脸中的元信息格式转换 + + Args: + src (dict): 人脸中的元信息 + + Returns: + dict: 转换后的元信息 + """ + dst = {} + dst["media_name"] = src["video_name"] + dst["mediaid"] = src["video_name"] + dst["signature"] = src["video_file_hash_code"] + dst["fps"] = src["fps"] + dst["duration"] = src["duration"] + dst["frame_num"] = src["frame_num"] + dst["height"] = src["height"] + dst["width"] = src["width"] + return dst + + +def face_obj_2_tme_obj(src: dict) -> dict: + """人脸信息转换为 Object中的元信息 + + Args: + src (dict): 人脸框相关信息 + + Returns: + dict: 转换后的人脸信息 + """ + obj = {} + obj["category"] = "face" + obj["bbox"] = src["bbox"] + obj["kps"] = src["kps"] + obj["det_score"] = src["det_score"] + obj["gender"] = src["gender"] + obj["age"] = src["age"] + obj["trackid"] = src["roleid"] + return obj + + +def face_clips_2_tme_clips(src: list) -> list: + """人脸信息转换为Clip + + Args: + src (list): 人脸中 Clip 的多帧检测信息 + + Returns: + list: Clip 中的 frames信息 + """ + dst = [] + for idx, frame_perception in enumerate(src): + frame_dst = {} + frame_dst["frame_idx"] = frame_perception["frame_idx"] + objs = [] + if frame_perception["faces"] is not None: + for face in frame_perception["faces"]: + obj = face_obj_2_tme_obj(face) + objs.append(obj) + frame_dst["objs"] = objs + dst.append(frame_dst) + return dst + + +def face2TMEType(src: dict) -> dict: + """人脸检测的信息转换成 视频剪辑中的格式 + + Args: + src (dict): 人脸检测信息 + + Returns: + dict: 转换后的字典格式 + """ + meta_info = face_meta_2_tme_meta( + { + k: v + for k, v in src.items() + if k + not in [ + "face_detections", + "single_frame_transiton_score", + "all_frame_transiton_score", + "clips", + ] + } + ) + clips = face_clips_2_tme_clips(src["face_detections"]) + video_info = {"meta_info": meta_info, "sub_meta_info": [], "clips": clips} + return video_info + + +def load_multi_face( + path_lst: str, +) -> dict: + """读取多个人脸检测结果文件，转化成VideoInfo对应的字典格式。 + + Args: + path_lst (str or [str]): 人脸检测结果文件 + + Returns: + dict: VideoInfo对应的字典格式, key是 文件名 + """ + if not isinstance(path_lst, list): + path_lst = [path_lst] + face_info_dct = {} + for path in path_lst: + filename, ext = get_file_name_ext(os.path.basename(path)) + face_info = load_dct_from_file(path) + face_info = face2TMEType(face_info) + face_info_dct[filename] = face_info + return face_info_dct + + +def face_roles2frames(src: dict, **kwargs: dict) -> List[Frame]: + """将roles字典转换为Frame + + Args: + src (dict): { + roleid: { + "bbox": { + "frame_idx": [ + [x1, y1, x2, y2] + ] + } + "names": str, + } + } + kwargs (dict): 便于其他需要的参数也传到Frame中去 + + Returns: + List[Frame]: _description_ + """ + frames = {} + for roleid, faces_info in src.items(): + if "name" not in faces_info or faces_info["name"] == "": + name = "unknown" + else: + name = faces_info["name"] + if "bbox" in faces_info: + frames_bbox = faces_info["bbox"] + for frameid, bbox in frames_bbox.items(): + frameid = int(frameid) + if frameid not in frames: + frames[frameid] = {"objs": [], "frame_idx": frameid} + obj = { + "name": name, + "bbox": bbox[0], + "category": "person", + "obj_id": int(roleid), + } + obj = Object(**obj) + frames[frameid]["objs"].append(obj) + frame_obj_list = [] + for frameid in sorted(frames.keys()): + frame_args = frames[frameid] + frame_args.update(**kwargs) + frame = Frame(**frame_args) + frame_obj_list.append(frame) + return frame_obj_list + + +def clipseq_face_roles2frames(clips_roles: List[Dict], **kwargs: dict) -> FrameSeq: + frame_seq = [] + for roles in clips_roles: + frames = face_roles2frames(roles) + frame_seq.extend(frames) + frame_seq = sorted(frame_seq, key=lambda f: f.frame_idx) + return FrameSeq(frame_seq, **kwargs) diff --git a/MuseV/MMCM/mmcm/vision/video_map/load_video_map.py b/MuseV/MMCM/mmcm/vision/video_map/load_video_map.py new file mode 100755 index 0000000000000000000000000000000000000000..32af6d7219e9dd4f98a7817778136a18f92189d0 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/load_video_map.py @@ -0,0 +1,53 @@ +from .. import VideoMapSeq, VideoMetaInfo, VideoMap + + +def load_video_map( + video_map_paths, + video_paths, + emb_paths, + start: float = None, + end: None = None, + target_width_height_ratio: float = None, + target_width: float = None, + target_height: float = None, + **kwargs, +): + """读取视频谱面，转化成VideoInfo。当 videoinfo_path_lst 为列表时，表示多歌曲 + + Args: + videoinfo_path_lst (str or [str]): 视频谱面路径文件列表 + video_path_lst (str or [str]): 视频文件路径文件列表，须与videoinfo_path_lst等长度 + target_width_height_ratio (float): 目标视频宽高比 + target_width (int): 目标视频宽 + target_height (int): 目标视频高 + + Returns: + VideoInfo: 视频谱面信息 + """ + dct = { + "start": start, + "end": end, + "target_width_height_ratio": target_width_height_ratio, + "target_width": target_width, + "target_height": target_height, + } + if isinstance(video_map_paths, list): + video_map = VideoMapSeq.from_json_paths( + media_map_class=VideoMap, + media_paths=video_paths, + media_map_paths=video_map_paths, + emb_paths=emb_paths, + **dct, + **kwargs, + ) + if len(video_map) == 1: + video_map = video_map[0] + else: + video_map = VideoMap.from_json_path( + path=video_map_paths, + emb_path=emb_paths, + media_path=video_paths, + **dct, + **kwargs, + ) + return video_map diff --git a/MuseV/MMCM/mmcm/vision/video_map/shot_size.py b/MuseV/MMCM/mmcm/vision/video_map/shot_size.py new file mode 100755 index 0000000000000000000000000000000000000000..ea3cbc776c638d33b29ce136cbd247971e530eed --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/shot_size.py @@ -0,0 +1,32 @@ +import numpy as np + +from .vision_object import Object + + +def cal_shot_size_by_face(frame_width: int, frame_height: int, obj: Object) -> str: + """根据图像宽高和人脸框的大小判断人脸的景别 + + Args: + frame_width (int): 图像宽 + frame_height (int): 图像高 + obj (Object): 人脸检测框 + + Returns: + str: 根据人脸框信息计算的景别 + """ + obj_area = obj.area + frame_area = frame_height * frame_width + area_ratio = obj_area / frame_area + width_ratio = obj.width / frame_width + height_ratio = obj.height / frame_height + if height_ratio >= 0.7 or width_ratio >= 0.8: + shot_size = "ExtremeCloseUP" + elif height_ratio >= 0.5 or width_ratio >= 0.7: + shot_size = "CloseUp" + elif height_ratio >= 0.2 or width_ratio > 0.4: + shot_size = "MeiumShot" + elif height_ratio >= 0.1 or width_ratio >= 0.1: + shot_size = "FullShot" + else: + shot_size = "WideShot" + return shot_size diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_clip.py b/MuseV/MMCM/mmcm/vision/video_map/video_clip.py new file mode 100755 index 0000000000000000000000000000000000000000..a76b758d2d2c92224e49c6fbc54d554953b913a7 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_clip.py @@ -0,0 +1,519 @@ +from __future__ import annotations + +import os +import logging +from typing import Dict, List, Union +import logging + +import cv2 +import numpy as np +from moviepy.editor import ( + VideoFileClip, + concatenate_videoclips, + vfx, + CompositeVideoClip, + TextClip, +) + +from ...data import Clip, ClipSeq + +from ..config.CFG import CFG +from .face import face_roles2frames +from .video_process_with_moviepy import ( + crop_edge_2_even, + crop_target_bbox, + get_sub_mvpclip_by_time, +) +from .vision_frame import ( + Frame, + get_time_center_by_topkrole, + get_width_center_by_topkrole, +) +from ..utils.vision_util import round_up_to_even + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class VideoClip(Clip): + """可以自定义一些自己的处理方法，如台词渲染、片段拼接、等""" + + def __init__( + self, + time_start: float, + duration: float, + clipid: int = None, + media_type: str = None, + mediaid: str = None, + media_name: str = None, + video_path: str = None, + roles: Dict[str, Dict[str, Dict[str, List[float]]]] = None, + scenes: List[Dict] = None, + background: str = None, + scene_roles: list = None, + timepoint_type: int = None, + text: str = None, + stage: str = None, + path: str = None, + duration_num: int = None, + similar_clipseq: list = None, + frames: List[Frame] = None, + offset: float = 0.2, + dynamic: float = None, + camera_move: str = None, + **kwargs, + ): + """视频拆片段后的类定义 + + Args: + scene (_type_, optional): _description_. Defaults to None. + video_path (_type_, optional): _description_. Defaults to None. + roles (_type_, optional): _description_. Defaults to None. + background (_type_, optional): _description_. Defaults to None. + roles_name (_type_, optional): _description_. Defaults to None. + offset (float, optional): 读取moviepy 视频片段后，做掐头去尾的偏移操作， + 有利于解决夹帧问题，该参数表示减少的总时长，掐头去尾各一半时间. Defaults to None. + roles: + "roles": { + "9": { # 角色id + "bbox": { # + "839": [ # 帧id + [ + 461.8400573730469, + 110.67144012451172, + 685.0857543945312, + 379.3414001464844 + ] + ], + } + "name": "", + "conf_of_talking": -0.88, + } + } + } + """ + self.media_name = media_name + self.video_path = video_path + self.roles = roles + self.scenes = scenes + self.background = background + self.scenes_roles = scene_roles + self.frames = frames + self.camera_move = camera_move + self.offset = offset + super().__init__( + time_start, + duration, + clipid, + media_type, + mediaid, + timepoint_type, + text, + stage, + path, + duration_num, + similar_clipseq, + dynamic, + **kwargs, + ) + self.preprocess() + + def preprocess(self): + self.preprocess_clip() + self.preprocess_frames() + + def preprocess_clip(self): + self.spread_parameters() + + def preprocess_frames(self): + if self.frames is not None: + for frame in self.frames: + frame.preprocess() + + def spread_parameters(self): + target_keys = [ + "width", + "height", + "content_width", + "content_height", + "fps", + "frame_num", + ] + if self.frames is not None: + for k in target_keys: + if k in self.__dict__ and self.__dict__[k] is not None: + for frame in self.frames: + frame.__setattr__(k, self.__dict__[k]) + + @property + def time_end(self): + return self.time_start + self.duration + + def get_mvp_clip( + self, + ): + """获取当前Clip对应的moviepy的实际视频clip""" + return VideoFileClip(self.media_path).subclip(self.time_start, self.time_end) + + def get_offset_mvp_clip(self, clip=None, offset: float = None): + if clip is None: + clip = self.get_mvp_clip() + if offset is None: + offset = self.offset + duration = clip.duration + time_start = max(0, offset / 2) + time_end = min(duration, duration - offset / 2) + clip = clip.subclip(time_start, time_end) + return clip + + def get_clean_mvp_clip(self, clip=None): + """获取处理干净的 moviepy.VideoClip + + Args: + clip (VideoClip, optional): 待处理的VideoClip. Defaults to None. + + Returns: + VideoClip: 处理干净的 moviepy.VideoClip + """ + if clip is None: + clip = self.get_mvp_clip() + # offset + clip = self.get_offset_mvp_clip(clip=clip, offset=self.offset) + # content + clip = self.get_content_clip(clip=clip) + if self.target_width_height_ratio is not None: + clip = self.get_target_width_height_ratio_clip(clip=clip) + # logger.debug( + # "after get_target_width_height_ratio_clip: width={}, height={}, duration={}".format( + # clip.w, clip.h, clip.duration + # ) + # ) + if self.target_width is not None and self.target_height is not None: + clip = self.get_target_width_height_clip(clip=clip) + logger.debug( + "after get_target_width_height_clip: width={}, height={}, duration={}".format( + clip.w, clip.h, clip.duration + ) + ) + # crop width and height to even + clip = crop_edge_2_even(clip=clip) + return clip + + def get_content_clip(self, clip=None): + """根据 content_box信息获取实际视频内容部分，非视频内容部分往往是黑边（可能含有字幕） + + Args: + clip (moviepy.VideoClip, optional): 可能有黑边的 moviepy.VideoClip. Defaults to None. + + Returns: + VideoClip: 对应视频实际内容的 moviepy.VideoClip + """ + if clip is None: + clip = self.get_mvp_clip() + # 获取内容部分，剔除黑边 + if self.content_box is not None: + clip = crop_target_bbox(clip, self.content_box) + return clip + + def get_target_width_height_ratio_clip(self, clip=None): + """获取符合目标宽高比的内容部分，目前 + 1. 默认高度等于输入高度 + 2. 当有人脸框时，使用中间帧的宽中心作为获取中心； + 2. 其他情况，使用图像中心位置 + + Args: + clip (moviepy.VideoClip, optional): 原始分辨率的视频内容. Defaults to None. + + Returns: + moviepy.VideoClip: 符合宽高比目标的内容 + """ + if clip is None: + clip = self.get_mvp_clip() + target_height = clip.h + target_width = round_up_to_even(target_height * self.target_width_height_ratio) + target_width = min(target_width, clip.w) + # TODO: 有待确定中间crop的使用范围 + if self.roles is None or len(self.roles) == 0: + target_center_x = clip.w / 2 + else: + target_center_x = get_width_center_by_topkrole( + objs=self.roles, coord_offset=[self.content_box[0], self.content_box[1]] + ) + target_center_x = min( + max(target_width / 2, target_center_x), + clip.w - target_width / 2, + ) + target_coord = [ + target_center_x - target_width / 2, + 0, + target_center_x + target_width / 2, + target_height, + ] + clip = clip.crop(*target_coord) + return clip + + def get_target_width_height_clip(self, clip=None): + """获取符合目标宽高的内容部分 + + Args: + clip (moviepy.VideoClip, optional): 待处理的视频内容. Defaults to None. + + Returns:fontsize + moviepy.VideoClip: 符合宽高目标的内容 + """ + if clip is None: + clip = self.get_mvp_clip() + if self.target_width and self.target_height: + logger.debug( + "get_target_width_height_clip: clip.w={}, clip.h={}, target_width={}, target_height={}".format( + clip.w, clip.h, self.target_width, self.target_height + ) + ) + clip = clip.resize(newsize=(self.target_width, self.target_height)) + return clip + + def get_subclip_by_time( + self, final_duration: float, clip=None, method: str = "speed" + ): + """根据视频长度，对齐到指定长度 + + Args: + video_clips (list[VideoClipSeq]): 媒体文件片段序列 + final_duration (float): 目标长度 + mode (int, optional): how to chang video length. Defaults to `speed`. + speed: chang length by sample + cut: change length by cut middle length + None: change length accorrding difference of clip duration and final_duration. Defaults to None. + + Raises: + NotImplementedError: _description_ + + Returns: + VideoClip: 读取、对齐后moviepy VideoClip + """ + if clip is None: + clip = self.get_clean_mvp_clip() + if self.roles is None or len(self.roles) == 0: + center_ratio = 0.5 + else: + frame_idx = get_time_center_by_topkrole(self.roles) + center_ratio = (frame_idx - self.frame_start) / ( + self.frame_end - self.frame_start + ) + clip = get_sub_mvpclip_by_time( + clip=clip, + final_duration=final_duration, + method=method, + center_ratio=center_ratio, + ) + if CFG.RunningMode == "DEBUG": + clip = self.vis(clip=clip) + return clip + + def vis(self, clip=None): + """将clip的原始信息可视化到左上角，开始点加红框 + + + Args: + clip (moviepy.VideoClip): 待可视化的视频片段 + + Returns: + moviepy.VideoClip: 可视化后的视频片段 + """ + if clip is None: + clip = self.get_clean_mvp_clip() + clip = self.vis_meta_info(clip=clip) + if CFG.VisFrame: + clip = self.vis_frames(clip=clip) + return clip + + def vis_meta_info(self, clip): + txt = "videoname={}\nclipid={}\nt_start={}\nduration={}\n".format( + os.path.basename(self.media_name), + self.clipid, + self.time_start, + self.duration, + ) + txt_clip = TextClip( + txt, + fontsize=CFG.DebugFontSize, + color=CFG.DebugTextColorsCls.color, + font=CFG.Font, + stroke_width=CFG.DebugTextStrokeWidth, + ) + txt_clip = txt_clip.set_duration(clip.duration) + txt_clip = txt_clip.set_position(("left", "top")) + clip = CompositeVideoClip([clip, txt_clip]) + return clip + + def vis_frames(self, clip): + if self.frames is None: + return clip + for frame in self.frames: + clip = self.vis_frame(clip=clip, frame=frame) + return clip + + def vis_frame(self, clip, frame): + txt = "" + txt += "\n{}".format(frame.shot_size) + txt_clip = TextClip( + txt, + fontsize=CFG.DebugFontSize, + color=CFG.DebugFrameTextColor, + font=CFG.Font, + stroke_width=CFG.DebugTextStrokeWidth, + ) + txt_clip = txt_clip.set_duration(CFG.DebugFrameTextDuration) + txt_clip = txt_clip.set_position(("right", "top")) + # TODO: vis objs + clip = CompositeVideoClip( + [clip, txt_clip.set_start(frame.timestamp - self.time_start)] + ) + return clip + + @classmethod + def from_data(cls, data: Dict): + return VideoClip(**data) + + @property + def roles_name(self) -> List: + if self.roles is None: + return [] + roles_name = [r["name"] for r in self.roles if "name" in r] + return list(set(roles_name)) + + def has_roles_name(self, role_names: Union[str, List[str]], mode: str) -> bool: + if not isinstance(role_names, list): + role_names = [role_names] + role_set = set(role_names) & set(self.roles_name) + if mode == "all": + return len(role_set) == len(role_names) + elif mode == "least": + return len(role_set) > 0 + else: + raise ValueError(f"mode only support least or all, but given {mode}") + + +class VideoClipSeq(ClipSeq): + """可以自定义一些自己的处理方法，如台词渲染、片段拼接、等""" + + def __init__(self, clipseq: List[VideoClip]) -> None: + super().__init__(clipseq) + + def __getitem__(self, i: int) -> ClipSeq: + clipseq = super().__getitem__(i) + if isinstance(clipseq, Clip): + return clipseq + elif isinstance(clipseq, list): + return VideoClipSeq(clipseq) + else: + return VideoClipSeq(clipseq.clipseq) + + def get_mvp_clip(self, method="rough"): + """获取ClipSeq对应的 moviepy中的视频序列 + + Args: + method (str, optional): 支持 rough 和 fine 两种模式. Defaults to "rough". + rough: 获取clipseq中的开头结束时间，直接从视频文件中读取；，适用于整个clipseq都是同一个视频文件且连续； + fine: 每个clip分别从视频文件中获取，再拼在一起，适合clipseq中时间不连续或者含有多种视频； + + Raises: + ValueError: 不支持的 moviepy.VideoClip 获取方式 + + Returns: + moviepy.VideoClip: clipseq 对应的 moviepy.VideoClip + """ + if method == "rough": + time_start = self.clipseq[0].time_start + time_end = self.clipseq[-1].time_end + video_path = self.clipseq[0].video_path + clip = VideoFileClip(video_path).subclip(time_start, time_end) + elif method == "fine": + clipseq = [c.get_mvp_clip() for c in self.clipseq] + clip = concatenate_videoclips(clipseq) + else: + raise ValueError( + "only support method=[rough, fine], but given {}".format(method) + ) + return clip + + def get_clean_mvp_clipseq( + self, + ): + """获取处理干净的 moviepy.VideoClip + + Returns: + moviepy.VideoClip: 干净的 moviepy.VideoClip + """ + clipseq = [c.get_clean_mvp_clip() for c in self.clipseq] + return clipseq + + def get_time_center( + self, + ): + pass + + def get_subclip_by_time( + self, + clipseq, + final_duration: float, + method: str = None, + ): + """根据视频长度，对齐到指定长度，现在默认每个clip按照比例取时长。 + + Args: + video_clips (list[VideoClipSeq]): 媒体文件片段序列 + final_duration (float): 目标长度 + method (int, optional): how to chang video length. Defaults to `None`. + speed: chang length by sample + cut: change length by cut middle length + None: change length accorrding difference of clip duration and final_duration. Defaults to None. + + Returns: + VideoClip: 读取、对齐后 moviepy VideoClip + """ + clipseq_duration = np.sum([c.duration for c in clipseq]) + final_duration_per_clip = [ + c.duration / clipseq_duration * final_duration for c in clipseq + ] + clipseq = [ + self.clipseq[i].get_subclip_by_time( + final_duration=final_duration_per_clip[i], + method=method, + clip=clip, + ) + for i, clip in enumerate(clipseq) + ] + clip = concatenate_videoclips(clipseq) + clip = clip.fx(vfx.speedx, final_duration=final_duration) + return clip + + def get_target_mvp_clip( + self, + final_duration: float, + method: str = None, + ): + """获取符合所有目标的 moviepy.VideoClip，当前目标有 + 1. 去黑边、值得宽高比、值得宽高 + 2. 指定时间长度 + + Args: + final_duration (float): 目标长度 + method (str, optional): 时间变长的方法. Defaults to None. + + Returns: + moviepy.VideoClip: 符合目标的moviepy.VideoClip + """ + clipseq = self.get_clean_mvp_clipseq() + clip = self.get_subclip_by_time( + clipseq=clipseq, final_duration=final_duration, method=method + ) + return clip + + @classmethod + def from_data(cls, clipseq: List[Dict]) -> VideoClipSeq: + new_clipseq = [] + for clip in clipseq: + video_clip = VideoClip.from_data(clip) + new_clipseq.append(video_clip) + video_clipseq = VideoClipSeq(new_clipseq) + return video_clipseq diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_dataset.py b/MuseV/MMCM/mmcm/vision/video_map/video_dataset.py new file mode 100755 index 0000000000000000000000000000000000000000..cc52871d0b82baf8594df62025ec7a106a2f41b6 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_dataset.py @@ -0,0 +1,85 @@ +import os + +import cv2 +import numpy as np +import torch +from torch.utils.data import Dataset, BatchSampler, Sampler +from moviepy.editor import VideoFileClip + + +# TODO: 待后续设计、处理 +class OpenCVVideoDataset(Dataset): + def __init__( + self, + video_path, + ) -> None: + super().__init__() + self.video_path = video_path + self.cap = cv2.VideoCapture(self.video_path) + + def __call__(self, idx) -> np.array: + self.cap.set(2, idx) + frame = self.cap.read() + return frame + + def close(self): + self.cap.release() + + +class MoviepyVideoDataset(Dataset): + def __init__(self, video_path, mode="time") -> None: + self.video_path = video_path + self.videoclip = VideoFileClip(video_path) + self.mode = mode + + def __call__(self, t): + if self.mode == "int": + t = t / self.videoclip.fps + frame = self.videoclip.get_frame(t) + return frame + + def __len__(self): + n_total = self.videoclip.duration * self.videoclip.fps + return n_total + + +def generate_videoclip_batchsampler(video_info): + sampler = [] + fps = video_info["fps"] + for i, clip in enumerate(video_info["slices"]): + time_start = clip["time_start"] + duration = clip["duration"] + n_start = int(time_start * fps) + n_frame = int(duration * fps) + sampler.append(range(n_start, n_frame, 1)) + return sampler + + +class VideoClipBatchSampler(Sampler): + def __init__(self, sampler) -> None: + self.sampler = sampler + + def __iter__(self): + return iter(self.sampler) + + +def iter_videoclip(model, videoinfo): + pass + + +if __name__ == "__main__": + import json + + PROJECT_DIR = os.path.join(os.path.dirname(__file__), "../..") + DATA_DIR = os.path.join(PROJECT_DIR, "data") + TEST_IMG_PATH = os.path.join(DATA_DIR, "KDA_ALLOUT.jpeg") + TEST_VIDEO_PATH = os.path.join(DATA_DIR, "video.mp4") + TEST_VIDEOMAP_PATH = os.path.join(DATA_DIR, "videomap_大鱼海棠.json") + with open(TEST_VIDEOMAP_PATH, "r") as f: + videoinfo = json.load(f) + videoinfo["fps"] = 30 + sampler = generate_videoclip_batchsampler(videoinfo) + videoclip_batchsampler = VideoClipBatchSampler(sampler=sampler) + print("videoclip_batchsampler length", videoclip_batchsampler) + for i, batch in enumerate(videoclip_batchsampler): + print(i, batch) diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_lyric.py b/MuseV/MMCM/mmcm/vision/video_map/video_lyric.py new file mode 100755 index 0000000000000000000000000000000000000000..20e33564e7393dac0b41a1c1ba5766fc9dcbd326 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_lyric.py @@ -0,0 +1,182 @@ +import json +from typing import Tuple +import logging + +from librosa.core.audio import get_duration +from moviepy.editor import CompositeVideoClip, concatenate_videoclips, TextClip +import moviepy as mvp + +ignored_log = logging.getLogger("PIL") +ignored_log.setLevel(level=logging.INFO) + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +def generate_lyric_video_from_music_map( + music_map: dict, + size=None, + duration: float = None, + fontsize: float = 50, + padding: int = 0, + gap_th: float = 2, + font: str = "STXinwei", +): + """从音乐谱面生成歌词 videoclip + + Args: + music_map (dict): 音乐谱面，meta_info中必须含有歌词clip信息 + size (_type_, optional): _description_. Defaults to None. + duration (float, optional): 歌词总时长. Defaults to None. + fontsize (float, optional): 歌词字体大小. Defaults to 50. + padding (int, optional): _description_. Defaults to 0. + gap_th (float, optional): 补全歌词clip中的间隙部分. Defaults to 2. + font (str, optional): 字体. Defaults to "STXinwei"，需要安装. + + Returns: + moviepy.VideoClip: 生成的歌词视频 + """ + if isinstance(music_map, str): + music_map = MusicInfo(music_map) + lyric_clipseq = complete_clipseq( + clipseq=music_map.meta_info.lyric, duration=duration, gap_th=gap_th + ) + videoclips = [] + + if music_map.meta_info.media_name is not None: + media_name = music_map.meta_info.media_name + else: + media_name = "" + if music_map.meta_info.singer is not None: + singer = music_map.meta_info.singer + else: + singer = "" + if music_map.meta_info.album is not None: + album = music_map.meta_info.album + else: + album = "" + title = "{} {} {}".format(album, media_name, singer) + # if size is not None + title_clip = TextClip( + title, + fontsize=int(fontsize * 1.1), + color="white", + font=font, + stroke_width=2, + ) + title_clip = title_clip.set_duration(3) + for i, clip in enumerate(lyric_clipseq): + time_start = clip.time_start + duration = clip.duration + if clip.text is not None: + txt = clip.text + else: + txt = " " + logger.debug( + "render lyric, lyric={}, time_start={}, duration={}".format( + txt, time_start, duration + ) + ) + txt_clip = TextClip( + txt, fontsize=fontsize, color="white", font=font, stroke_width=2 + ) + txt_clip = txt_clip.set_duration(duration) + videoclips.append(txt_clip) + videoclips = concatenate_videoclips(videoclips, method="compose") + videoclips = CompositeVideoClip([videoclips, title_clip]) + videoclips.audio = None + if duration is None: + duration = lyric_clipseq[-1].time_start + lyric_clipseq[-1].duration + # videoclips.set_duration(duration) + return videoclips + + +def generate_lyric_video_from_lyric( + path: str, + audio_path: str = None, + duration: float = None, + size: Tuple = None, + fontsize: int = None, + padding: int = 0, + font: str = "Courier", +): + """从歌词文件中生成歌词视频 + + Args: + path (str): 歌词文件 + audio_path (str, optional): 对应的音频文件，主要用于提取音频总时长. Defaults to None. + duration (float, optional): 歌曲总时长. Defaults to None. + size (Tuple, optional): _description_. Defaults to None. + fontsize (int, optional): 渲染的歌词字体大小. Defaults to None. + padding (int, optional): _description_. Defaults to 0. + + Returns: + moviepy. VideoClip: 渲染好的歌词视频 + """ + if audio_path is not None: + duration = get_duration(audio_path) + music_map = generate_lyric_map(path=path, duration=duration) + clip = generate_lyric_video_from_music_map( + music_map, + size=size, + duration=duration, + padding=padding, + fontsize=fontsize, + font=font, + ) + return clip + + +def render_lyric2video( + videoclip, + lyric: dict, + lyric_info_type: str = "music_map", + fontsize: int = 25, + font: str = "Courier", + audio_path: str = None, + duration: float = None, + padding: int = 0, +): + """对视频进行歌词渲染 + + Args: + videoclip (moviepy.VideoClip): 待渲染的视频 + lyric (dict): 歌词信息，也可以是歌词路径 + lyric_info_type (str, optional): 歌词类型，可以是 qrc， 也可以是谱面. Defaults to "music_map". + fontsize (int, optional): 渲染的歌词大小. Defaults to 25. + audio_path (str, optional): 音频路径，主要提供一些必要信息. Defaults to None. + duration (float, optional): 音频总时长. Defaults to None. + padding (int, optional): _description_. Defaults to 0. + + Raises: + ValueError: _description_ + + Returns: + moviepy.VideoClip: 渲染好歌词的视频文件 + """ + size = (videoclip.w, videoclip.h) + + if fontsize is None: + fontsize = int(videoclip.w / 1280 * fontsize) + if lyric_info_type == "lyric": + lyric_clip = generate_lyric_video_from_lyric( + lyric, + size=size, + fontsize=fontsize, + font=font, + ) + elif lyric_info_type == "music_map": + lyric_clip = generate_lyric_video_from_music_map( + lyric, + size=size, + fontsize=fontsize, + font=font, + ) + else: + raise ValueError("not support {}".format(lyric_info_type)) + lyric_clip = lyric_clip.set_position(("center", "bottom")) + lyric_video_clip = CompositeVideoClip([videoclip, lyric_clip], size=size) + lyric_video_clip.audio = videoclip.audio + logger.debug("lyric_clip: duration={}".format(lyric_clip.duration)) + return lyric_video_clip diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_map.py b/MuseV/MMCM/mmcm/vision/video_map/video_map.py new file mode 100755 index 0000000000000000000000000000000000000000..50dca72050f1360d7c8f57371c2721597a751c0f --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_map.py @@ -0,0 +1,167 @@ +from __future__ import annotations + +from typing import Dict, List + +from moviepy.editor import VideoFileClip + +from ...data import ( + MediaMap, + MetaInfo, + MetaInfoList, + Clip, + ClipSeq, + H5pyMediaMapEmb, + MediaMapEmb, + MediaMapSeq, +) +from ...utils import load_dct_from_file + +from .video_clip import VideoClipSeq +from .video_meta_info import VideoMetaInfo +from .vision_object import Roles +from .vision_frame import FrameSeq + + +class VideoMap(MediaMap): + def __init__( + self, + meta_info: VideoMetaInfo = None, + clipseq: VideoClipSeq = None, + frameseq: FrameSeq = None, + stageseq: VideoClipSeq = None, + leading_roles: Roles = None, + emb: MediaMapEmb = None, + **kwargs, + ): + super().__init__(meta_info, clipseq, stageseq, frameseq, emb, **kwargs) + self.leading_roles = leading_roles + + def preprocess(self): + super().preprocess() + self.spread_metainfo_2_clip( + target_keys=[ + "media_path", + "media_map_path", + "emb_path", + "media_duration", + "mediaid", + "media_name", + "target_width", + "target_height", + "content_box", + "target_width_height_ratio", + "emb", + ] + ) + + @property + def media_path(self): + return self.meta_info.media_path + + @property + def media_map_path(self): + return self.meta_info.media_map_path + + @property + def fps(self): + return self.meta_info.fps + + def to_dct( + self, target_keys: List[str] = None, ignored_keys: List[str] = None + ) -> Dict: + dct = {} + dct["meta_info"] = self.meta_info.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + dct["clipseq"] = self.clipseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + if self.frameseq is not None: + dct["frameseq"] = self.frameseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + if self.stageseq is not None: + dct["stageseq"] = self.stageseq.to_dct( + target_keys=target_keys, ignored_keys=ignored_keys + ) + if self.stageseq is not None: + dct["leading_roles"] = self.leading_roles.to_dct() + return dct + + @classmethod + def from_path( + cls, shot_transition: str, scene_transition: str, face: str + ) -> VideoMap: + raise NotImplementedError + + @classmethod + def from_dir(cls, path: str) -> VideoMap: + shot_transition = None + scene_transition = None + semantic_emb = None + face = None + return cls.from_path(shot_transition, scene_transition) + + @classmethod + def from_data( + cls, data: Dict, emb: H5pyMediaMapEmb, media_path: str = None, **kwargs + ) -> VideoMap: + meta_info = VideoMetaInfo.from_data(data.get("meta_info", {})) + meta_info.media_path = media_path + clipseq = VideoClipSeq.from_data(data.get("clipseq", [])) + frameseq = FrameSeq.from_data(data.get("frameseq", [])) + stageseq = VideoClipSeq.from_data(data.get("stageseq", [])) + leading_roles = Roles.from_data(data.get("leading_roles", [])) + target_keys = ["meta_info", "clipseq", "frameseq", "stageseq", "leading_roles"] + dct = {k: data[k] for k in data.keys() if k not in target_keys} + dct.update(**kwargs) + video_map = VideoMap( + meta_info=meta_info, + clipseq=clipseq, + frameseq=frameseq, + stageseq=stageseq, + leading_roles=leading_roles, + emb=emb, + **dct, + ) + return video_map + + +class VideoMapSeq(MediaMapSeq): + def __init__(self, maps: List[VideoMap]) -> None: + super().__init__(maps) + + @property + def fps(self): + return max(m.fps for m in self.maps) + + +# def merge_face_into_video_info(video_info: VideoInfo, face: dict) -> VideoInfo: +# """融合读取的多个人脸检测信息到 视频谱面中 + +# Args: +# video_info (VideoInfo): 待融合的视频谱面 +# face (dict): 待融合的人脸检测信息，key是视频文件名 + +# Returns: +# VideoInfo: 融合后的人脸谱面信息 +# """ +# for c_idx, clip in enumerate(video_info.clipseq): +# frame_start = clip.frame_start +# frame_end = clip.frame_end +# frames_in_clip = [] +# videoinfo_name, ext = get_file_name_ext(os.path.basename(clip.videoinfo_path)) +# video_face = face[videoinfo_name] +# for face_frame in video_face["clips"]: +# if ( +# face_frame["frame_idx"] >= frame_start +# and face_frame["frame_idx"] <= frame_end +# ): +# frame = Frame( +# **face_frame, +# width=video_info.meta_info.width, +# height=video_info.meta_info.height, +# ) +# frames_in_clip.append(frame) +# video_info.clipseq[c_idx].frames = frames_in_clip +# return video_info diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_meta_info.py b/MuseV/MMCM/mmcm/vision/video_map/video_meta_info.py new file mode 100755 index 0000000000000000000000000000000000000000..c983ae1940c9159839c90399b38b365f227666ce --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_meta_info.py @@ -0,0 +1,181 @@ +from __future__ import annotations + +from functools import partial +import json +import os +from tracemalloc import start +from typing import List +import logging + +import cv2 +import numpy as np +from moviepy.editor import ( + VideoFileClip, + concatenate_videoclips, + vfx, + CompositeVideoClip, + TextClip, +) +import ffmpeg + +from ...data import Item, Items +from ...data import MetaInfo +from ...utils.time_util import timestr_2_seconds +from ...utils.util import convert_class_attr_to_dict +from .video_clip import VideoClipSeq + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class VideoMetaInfo(MetaInfo): + def __init__( + self, + mediaid=None, + media_duration=None, + media_path=None, + media_map_path=None, + media_name=None, + signature: str = None, + height: int = None, + width: int = None, + target_width: int = None, + target_height: int = None, + start: float = None, + end: float = None, + ext: str = None, + other_channels=None, + content_box: List[float] = None, + **kwargs, + ): + """_summary_ + + Args: + video_path (_type_, optional): _description_. Defaults to None. + videoinfo_path (_type_, optional): _description_. Defaults to None. + """ + + self.width = width + self.height = height + self.target_width = target_width + self.target_height = target_height + self.other_channels = other_channels + self.content_box = content_box + super().__init__( + mediaid, + media_name, + media_duration, + signature, + media_path, + media_map_path, + start, + end, + ext, + **kwargs, + ) + + def preprocess(self): + super().preprocess() + self.set_content_box() + + def set_content_box(self): + if self.content_box is None: + self.content_box = [ + 0, + 0, + self.width, + self.height, + ] + self.content_width = self.content_box[2] - self.content_box[0] + self.content_height = self.content_box[3] - self.content_box[1] + + @classmethod + def from_video_path(cls, path) -> VideoMetaInfo: + filename = os.path.splitext(os.path.basename(path))[0] + video_channel, other_channels = get_metainfo_by_ffmpeg(path) + return VideoMetaInfo( + mediaid=filename, other_channels=other_channels, **video_channel + ) + + @classmethod + def from_data(cls, data) -> VideoMetaInfo: + return VideoMetaInfo(**data) + + +def get_metainfo_by_opencv(path: str) -> dict: + """使用opencv获取视频的元信息，主要有width, height, frame_count, fps + + Args: + path (str): 视频路径 + + Returns: + dict: 视频相关信息， + """ + cap = cv2.VideoCapture(path) + dct = {} + # Check if camera opened successfully + if not cap.isOpened(): + logger.error("Error opening video stream or file") + dct["width"] = cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH) # float `width` + dct["height"] = cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT) # float `height` + dct["frame_count"] = cap.get(cv2.CAP_PROP_FRAME_COUNT) + dct["fps"] = cap.get(cv2.cv.CV_CAP_PROP_FPS) + return dct, None + + +def get_metainfo_by_ffmpeg(path: str) -> dict: + dct = {} + multi_channels_info = ffmpeg.probe(path)["streams"] + other_channels = [ + channel for channel in multi_channels_info if channel["codec_type"] != "video" + ] + video_channel = [ + channel for channel in multi_channels_info if channel["codec_type"] == "video" + ][0] + if "duration" in video_channel: + video_duration = video_channel["duration"] + elif "DURATION" in video_channel: + video_duration = video_channel["DURATION"] + elif "DURATION-en" in video_channel: + video_duration = video_channel["DURATION-en"] + elif "DURATION-eng" in video_channel: + video_duration = video_channel["DURATION-eng"] + elif "tags" in video_channel and "duration" in video_channel["tags"]: + video_duration = video_channel["tags"]["duration"] + elif "tags" in video_channel and "DURATION" in video_channel["tags"]: + video_duration = video_channel["tags"]["DURATION"] + elif "tags" in video_channel and "DURATION-en" in video_channel["tags"]: + video_duration = video_channel["tags"]["DURATION-en"] + elif "tags" in video_channel and "DURATION-eng" in video_channel["tags"]: + video_duration = video_channel["tags"]["DURATION-eng"] + else: + logger.warning("cant find video_duration :{}".format(path)) + video_duration = None + if video_duration is not None: + video_duration = timestr_2_seconds(video_duration) + avg_frame_rate = float(video_channel["avg_frame_rate"].split("/")[0]) / float( + video_channel["avg_frame_rate"].split("/")[1] + ) + time_base = float(video_channel["time_base"].split("/")[0]) / float( + video_channel["time_base"].split("/")[1] + ) + start_pts = ( + int(float(video_channel["start_pts"])) if "start_pts" in video_channel else None + ) + start_time = ( + int(float(video_channel["start_time"])) + if "start_time" in video_channel + else None + ) + dct = { + "media_duration": video_duration, + "height": int(video_channel["height"]), + "width": int(video_channel["width"]), + "codec_type": video_channel["codec_type"], + # "display_aspect_ratio": video_channel["display_aspect_ratio"], + "avg_frame_rate": avg_frame_rate, + "time_base": time_base, + "start_pts": start_pts, + "start_time": start_time, + "fps": avg_frame_rate, + } + return dct, other_channels diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_process.py b/MuseV/MMCM/mmcm/vision/video_map/video_process.py new file mode 100755 index 0000000000000000000000000000000000000000..0ab12299dd0a02a323dfcb45ad7a52b48c5eb61a --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_process.py @@ -0,0 +1,69 @@ +import numpy as np +import cv2 + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class VideoClipOperator(object): + def __init__(self) -> None: + pass + + def __call__(self, *args, **kwds): + pass + + +class VSELength(VideoClipOperator): + def __init__(self, time_start, duration, target, change_length_func) -> None: + self.time_start = time_start + self.duration = duration + self.target = target + self.change_length_func = change_length_func + + def __call__(self, *args, **kwds): + return super().__call__(*args, **kwds) + + +class EditedVideoWriter(object): + """do operators to videoclip + + Args: + operators ([[VideoClipOperator,VideoClipOperator], [VideoClipOperator]]): + """ + + def __init__(self, operators): + self.operators = operators + + def __call__(self, video, out): + """ + 1. open out path + 2. do operator to video, return edited video clip + 3. save + + Args: + video (_type_): _description_ + out (_type_): _description_ + """ + cap = cv2.VideoCapture(video) + # Check if camera opened successfully + if cap.isOpened() == False: + logger.error("Error opening video stream or file") + + out = cv2.VideoWriter( + out, + cv2.VideoWriter_fourcc("M", "J", "P", "G"), + 10, + (self.width, self.height), + ) + # float `width` + for clip_operator in self.operators: + frames = clip_operator( + width=cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH), + height=cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT), + frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT), + fps=cap.get(cv2.cv.CV_CAP_PROP_FPS), + ) + for frame in frames: + out.write(frame) + out.release() diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_process_with_moviepy.py b/MuseV/MMCM/mmcm/vision/video_map/video_process_with_moviepy.py new file mode 100755 index 0000000000000000000000000000000000000000..96aace9cea22b13905e284d7ef227997efe1a02a --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_process_with_moviepy.py @@ -0,0 +1,209 @@ +import math +from heapq import nsmallest +import logging + +import numpy as np +import cv2 +from moviepy.editor import ( + VideoFileClip, + VideoClip, + concatenate_videoclips, + vfx, + TextClip, + CompositeVideoClip, +) + +from ..utils.vision_util import ( + cal_crop_coord, + round_up_coord_to_even, + cal_small_bbox_coord_of_big_bbox, +) + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class VideoClipOperator(object): + def __init__(self, *args, **kwds) -> None: + pass + + def __call__(self, *args, **kwds): + pass + + +def get_subclip_from_clipseq_by_time(): + pass + + +def get_mvpclip_from_clip_by_time( + clips, final_duration: float, method: str = None, delta=0 +): + """根据视频长度，对齐到指定长度 + + Args: + clips (VideoClipSeq): 媒体文件片段序列 + final_duration (float): 目标长度 + method (int, optional): how to chang video length. Defaults to `None`. + speed: chang length by sample + cut: change length by cut middle length + None: change length accorrding difference of clip duration and final_duration. Defaults to None. + + Returns: + VideoClip: 读取、对齐后moviepy VideoClip + """ + n_clips = len(clips) + video_clips = [] + for i, clip in enumerate(clips): + start_delta = 0 + end_delta = 0 + # TODO: 为了解决夹帧问题，视视觉片段长音乐片段一些，便于只取中间部分。 + ## 适用于多个视频源的片段 + ## 适用于同一个视频源的 多个连续片段 + if n_clips > 1: + if i == 0: + start_delta = delta + if i == n_clips - 1: + end_delta = delta + else: + start_delta = delta + end_delta = delta + video_clip = clip.get_mvp_clip(start_delta=start_delta, end_delta=end_delta) + video_clips.append(video_clip) + video_clips = concatenate_videoclips(clips=video_clips, method="compose") + video_clips = get_sub_mvpclip_by_time( + clip=video_clips, final_duration=final_duration, method=method + ) + return video_clips + + +def get_sub_mvpclip_by_time( + clip, final_duration: float, method: str = "speed", center_ratio: float = 0.5 +): + duration = clip.duration + center = duration * center_ratio + center = min(max(center, final_duration / 2), duration - final_duration / 2) + if method == "speed": + clip = clip.fx(vfx.speedx, final_duration=final_duration) + elif method == "cut" or method is None: + if duration >= final_duration: + t_start = center - final_duration / 2 + t_end = center + final_duration / 2 + clip = clip.subclip(t_start, t_end) + logger.debug( + "[cut_clip_time]: change length by cut: t_start={:.3f}, t_end={:.3f}, duration={:.3f}, final_duration={:.3f}".format( + t_start, t_end, duration, final_duration + ) + ) + clip = clip.fx(vfx.speedx, final_duration=final_duration) + else: + raise NotImplementedError( + "var_video_clip_length do not support mode={}".format(clip) + ) + return clip + + +def crop_by_ratio( + clip, target_width_height_ratio, restricted_bbox=None, need_round2even=False +): + """将原视频中的有效部分剪辑成目标宽高比，有效部分用坐标表示，一般来说是非黑边、非水印位置 + + Args: + clip (VideoClip): moviepy中的视频片段 + target_width_height_ratio (float): 目标宽高比，常见的有2.35, 1.777, 0.75, 1, 0.5625 + restricted_bbox ((float, float, float, float), optional): (x1, y1, x2, y2). Defaults to None. + + Returns: + VideoClip: 剪辑好的moviepy视频片段 + """ + width = clip.w + height = clip.h + target_coord = cal_crop_coord( + width=width, + height=height, + target_width_height_ratio=target_width_height_ratio, + restricted_bbox=restricted_bbox, + ) + if need_round2even: + target_coord = round_up_coord_to_even(*target_coord) + clip = clip.crop(*target_coord) + return clip + + +def crop_by_perception( + clip, + target_width_height_ratio: float, + perception: dict, + need_round2even: bool = True, +): + """将原视频中的有效部分剪辑成目标宽高比，有效部分用坐标表示，一般来说是非黑边、非水印位置 + + Args: + clip (VideoClip): moviepy中的视频片段 + target_width_height_ratio (float): 目标宽高比，常见的有2.35, 1.777, 0.75, 1, 0.5625 + + Returns: + VideoClip: 剪辑好的moviepy视频片段 + """ + + return crop_by_face_clip( + clip, target_width_height_ratio, perception, need_round2even + ) + + +def crop_by_face_clip( + clip, + target_width_height_ratio: float, + perception, + need_round2even: bool = True, + topk: int = 1, +): + w = clip.w + h = clip.h + target_w = target_width_height_ratio * h + perception_objs = [] + if len(perception) > 0: + for i, frame_perception in enumerate(perception.clips): + if frame_perception.objs is not None: + for obj in frame_perception.objs: + perception_objs.append({"bbox": obj.bbox, "trackid": obj.trackid}) + # 如果没有目标人物，则依然使用中间crop方式 + if len(perception) == 0 or len(perception_objs) == 0: + return crop_by_ratio( + clip, target_width_height_ratio, need_round2even=need_round2even + ) + topk_rolid = nsmallest(topk, [obj["trackid"] for obj in perception_objs]) + topk_clip = [obj for obj in perception_objs if obj["trackid"] in topk_rolid] + # TODO: topk_clip 具有时间的先后顺序，先暂定取中间的obj的框作为参考 + target_idx = int(len(topk_clip) // 2) + x1, y1, x2, y2 = topk_clip[target_idx]["bbox"] + # TODO：当前适用于 target_w 大于 obj_width对应的人体宽度，当不符合条件时存在crop部分人体部分情况，此时应该提前过滤。 + obj_width = x2 - x1 + obj_height = y2 - y1 + obj_center_width = (x1 + x2) / 2 + obj_center_height = (y1 + y2) / 2 + target_coord = cal_small_bbox_coord_of_big_bbox( + bigbbox_width=w, + bigbbox_height=h, + smallbbox_width=target_w, + smallbbox_height=obj_height, + center_width=obj_center_width, + center_height=obj_center_height, + need_round2even=need_round2even, + ) + clip = clip.mv.crop(*target_coord) + return clip + + +def crop_target_bbox(clip, target_coord, need_round2even=False): + if need_round2even: + target_coord = round_up_coord_to_even(*target_coord) + clip = clip.crop(*target_coord) + return clip + + +def crop_edge_2_even(clip): + w, h = clip.w, clip.h + # logger.debug("crop_target_bbox-round_up_coord_to_even, before {} {} {} {}".format(0, 0, w, h)) + target_coord = round_up_coord_to_even(0, 0, w, h) + # logger.debug("crop_target_bbox-round_up_coord_to_even, after {} {} {} {}".format(target_coord[0], target_coord[1], target_coord[2], target_coord[3])) + clip = clip.crop(*target_coord) + return clip diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_process_with_opencv.py b/MuseV/MMCM/mmcm/vision/video_map/video_process_with_opencv.py new file mode 100755 index 0000000000000000000000000000000000000000..53445d4ef98575710d92a112472621f455848559 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_process_with_opencv.py @@ -0,0 +1,83 @@ +import numpy as np +import cv2 + +import logging + +logger = logging.getLogger(__name__) # pylint: disable=invalid-name + + +class VideoClipOperator(object): + def __init__(self) -> None: + pass + + def __call__(self, *args, **kwds): + pass + + +class VSELength(VideoClipOperator): + def __init__(self, time_start, duration, target, change_length_func) -> None: + self.time_start = time_start + self.duration = duration + self.target = target + self.change_length_func = change_length_func + + def __call__(self, cap, width, height, frame_count, fps): + start_frame_idx = int(self.time_start * fps) + src_frames_num = int(self.duration * fps) + dst_frames_num = int(self.target * fps) + # The first argument of cap.set(), number 2 defines that parameter for setting the frame selection. + # Number 2 defines flag CV_CAP_PROP_POS_FRAMES which is a 0-based index of the frame to be decoded/captured next. + # The second argument defines the frame number in range 0.0-1.0 + cap.set(2, start_frame_idx) + src_frames = [] + for i in range(src_frames_num): + frame = cap.read() + src_frames.append(frame) + src_frames = np.concatenate(src_frames, axis=0) + # Read the next frame from the video. + frames = self.change_length_func(src_frames, src_frames_num, dst_frames_num) + return frames + + +class EditedVideoWriter(object): + """do operators to videoclip + + Args: + operators ([[VideoClipOperator,VideoClipOperator], [VideoClipOperator]]): + """ + + def __init__(self, operators): + self.operators = operators + + def __call__(self, video, out): + """ + 1. open out path + 2. do operator to video, return edited video clip + 3. save + + Args: + video (_type_): _description_ + out (_type_): _description_ + """ + cap = cv2.VideoCapture(video) + # Check if camera opened successfully + if cap.isOpened() == False: + logger.error("Error opening video stream or file") + + out = cv2.VideoWriter( + out, + cv2.VideoWriter_fourcc("M", "J", "P", "G"), + 10, + (self.width, self.height), + ) + # float `width` + for clip_operator in self.operators: + frames = clip_operator( + width=cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH), + height=cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT), + frame_count=cap.get(cv2.CAP_PROP_FRAME_COUNT), + fps=cap.get(cv2.cv.CV_CAP_PROP_FPS), + ) + for frame in frames: + out.write(frame) + out.release() diff --git a/MuseV/MMCM/mmcm/vision/video_map/video_writer.py b/MuseV/MMCM/mmcm/vision/video_map/video_writer.py new file mode 100755 index 0000000000000000000000000000000000000000..813b75424cf767e77ad5dead85ad6e1738c3ed15 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/video_writer.py @@ -0,0 +1,8 @@ +def write_videoclip(clip, path, fps=None, n_thread=4): + getattr(clip, "write_videofile")( + path, + fps=fps, + codec="libx264", + threads=n_thread, + ffmpeg_params=["-pix_fmt", "yuv420p"], + ) diff --git a/MuseV/MMCM/mmcm/vision/video_map/vision_frame.py b/MuseV/MMCM/mmcm/vision/video_map/vision_frame.py new file mode 100755 index 0000000000000000000000000000000000000000..e316cb518a80926ecf309971fa0b3f4a065df060 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/vision_frame.py @@ -0,0 +1,153 @@ +from __future__ import annotations + +from typing import Any, Dict, List +import numpy as np + +from ...data import Item, Items +from ...utils.util import convert_class_attr_to_dict + +from .vision_object import Objects +from .shot_size import cal_shot_size_by_face + + +# 结构体定义 VideoMashup/videomashup/data_structure/vision_data_structure.py Frame +class Frame(Item): + def __init__( + self, + frame_idx: int, + objs: Objects = None, + scene: str = None, + caption: str = None, + shot_size: str = None, + shot_composition: str = None, + camera_angle: str = None, + field_depth: str = None, + content_width=None, + content_height=None, + **kwargs, + ) -> None: + """_summary_ + + Args: + frame_idx (int): 帧序号 + objs (Objects, optional): 检测到的物体. Defaults to None. + scene (str, optional): 场景，天空、机场等. Defaults to None. + caption (str, optional): 文本描述. Defaults to None. + shot_size (str, optional): 景别. Defaults to None. + shot_composition (str, optional): 构图. Defaults to None. + camera_angle (str, optional): 相机角度. Defaults to None. + field_depth (str, optional): 景深. Defaults to None. + """ + self.frame_idx = frame_idx + self.objs = objs if isinstance(objs, Objects) else Objects(objs) + self.scene = scene + self.caption = caption + self.shot_size = shot_size + self.shot_composition = shot_composition + self.camera_angle = camera_angle + self.field_depth = field_depth + self.content_height = content_height + self.content_width = content_width + self.__dict__.update(**kwargs) + self.preprocess() + + def preprocess(self): + if ( + self.shot_size is None + and self.content_height is not None + and self.content_width is not None + ): + self.shot_size = self.cal_shot_size() + + def cal_shot_size( + self, + ): + """计算当前帧的景别，目前使用人脸信息计算 + + Returns: + str: 景别，参考 VideoMashup/videomashup/data_structure/vision_data_structure.py + """ + if len(self.objs.objs) > 0: + obj = self.objs.get_max_bbox_obj() + shot_size = cal_shot_size_by_face( + frame_width=self.content_width, + frame_height=self.content_height, + obj=obj, + ) + else: + shot_size = "ExtremeWideShot" + return shot_size + + @property + def timestamp(self): + timestamp = self.frame_idx / self.fps + return timestamp + + def to_dct(self, target_keys: List[str] = None, ignored_keys: List[str] = None): + dct = super().to_dct(target_keys, ignored_keys=["objs"]) + dct["objs"] = self.objs.to_dct() + return dct + + +def get_width_center_by_topkrole( + objs: list, + coord_offset=None, +) -> float: + """通过视频镜头中的人物目标信息 计算适合剪辑的横轴中心点 + + Args: + objs (list): 目标信息 + coord_offset (list, optional): 原视频的坐标和检测目标的坐标信息可能存在偏移，如有可使用该偏移矫正. Defaults to None. + + Returns: + float: 横轴中心点 + """ + if coord_offset is None: + coord_offset = [0, 0] + min_roleid = str(min([int(x) for x in objs.keys()])) + target_role = objs[min_roleid] + bbox = [target_role["bbox"][x][0] for x in sorted(target_role["bbox"].keys())] + target_idx = int(len(bbox) // 2) + target_bbox = bbox[target_idx] + target_bbox = [ + target_bbox[0] - coord_offset[0], + target_bbox[1] - coord_offset[1], + target_bbox[2] - coord_offset[0], + target_bbox[3] - coord_offset[1], + ] + target_center_x = (target_bbox[0] + target_bbox[2]) / 2 + return target_center_x + + +def get_time_center_by_topkrole( + objs: list, +) -> float: + """计算主要目标人物的中心时间戳，适用于从原片段裁剪时序上的子片段，替代默认中间向两边 + + Args: + objs (list): 有时间戳信息的目标人物列表 + + Returns: + float: 中心时间戳 + """ + min_roleid = str(min([int(x) for x in objs.keys()])) + target_role = objs[min_roleid] + frame_idxs = [int(x) for x in target_role["bbox"].keys()] + frame_idx = np.mean(frame_idxs) + return frame_idx + + +class FrameSeq(Items): + def __init__(self, frameseq: Any = None, **kwargs): + super().__init__(frameseq) + self.frameseq = self.data + self.__dict__.update(**kwargs) + + @classmethod + def from_data( + cls, datas: List[Frame], frame_kwargs: Dict = None, **kwargs + ) -> FrameSeq: + if frame_kwargs is None: + frame_kwargs = {} + frameseq = [Frame(data, **frame_kwargs) for data in datas] + return FrameSeq(frameseq=frameseq, **kwargs) diff --git a/MuseV/MMCM/mmcm/vision/video_map/vision_object.py b/MuseV/MMCM/mmcm/vision/video_map/vision_object.py new file mode 100755 index 0000000000000000000000000000000000000000..672a70b283b1014ada6846bd18aab7abc7413694 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/video_map/vision_object.py @@ -0,0 +1,164 @@ +from __future__ import annotations +from typing import Iterable, Union, List, Dict, Any +import numpy as np + +from ...data import Items, Item +from ...utils.util import convert_class_attr_to_dict + + +class Object(Item): + def __init__( + self, + bbox: list, + category: str, + det_score: float = None, + kps: dict = None, + name: str = None, + text: str = None, + text_type: str = None, + obj_id: int = None, + attributes: Dict = None, + trackid: int = None, + **kwargs, + ) -> None: + """_summary_ + + Args: + bbox (list): _description_ + category (str): 物体类别，动物、文本、人、人脸等可以检测出框的物体 + det_score (float, optional): _description_. Defaults to None. + kps (dict, optional): _description_. Defaults to None. + name (str, optional): 物体姓名. Defaults to None. + text (str, optional): 可以用于OCR类的检测输出，具体描述该物体，可以是文本内容、类别具体描述、caption等. Defaults to None. + text_type (str, optional): 字幕，水印等. Defaults to None. + """ + self.bbox = bbox + self.category = category + self.det_score = det_score + self.kps = kps + self.name = name + self.text = text + self.text_type = text_type + self.obj_id = obj_id + self.attributes = attributes + self.trackid = trackid + self.__dict__.update(**kwargs) + + @property + def width(self): + return self.bbox[2] - self.bbox[0] + + @property + def height(self): + return self.bbox[3] - self.bbox[1] + + @property + def area(self): + return self.width * self.height + + +class Human(Object): + pass + + +class OpticalCharacter(Object): + pass + + +class Objects(Items): + def __init__(self, datas: List[Object] = None): + super().__init__(datas) + self.objs = self.data + + def get_target_category(self, target_category: list) -> list: + if not isinstance(target_category, list): + target_category = [target_category] + objs = Objects([obj for obj in self.objs if obj.category in target_category]) + return objs + + def get_max_bbox_obj(self): + areas = [obj.area for obj in self.objs] + max_index = np.argmax(areas) + obj = self.objs[max_index] + return obj + + def __len__( + self, + ): + return len(self.objs) + + def __getitem__(self, i): + """支持索引和切片操作，如果输入是整数则返回 Object ，如果是切片，则返回 Objects + + Args: + i (int or slice): 索引 + + Raises: + ValueError: 需要按照给的输入类型索引 + + Returns: + Object or Objects: + """ + if "int" in str(type(i)): + i = int(i) + if isinstance(i, int): + obj = self.objs[i] + return obj + elif isinstance(i, Iterable): + objs = [self.__getitem__(x) for x in i] + objs = Objects(objs) + return objs + elif isinstance(i, slice): + if i.step is None: + step = 1 + else: + step = i.step + objs = [self.__getitem__(x) for x in range(i.start, i.stop, step)] + objs = Objects(objs) + return objs + else: + raise ValueError( + "unsupported input, should be int or slice, but given {}, type={}".format( + i, type(i) + ) + ) + + +class Role(Item): + def __init__( + self, + name: str = None, + age: int = None, + gender: str = None, + gender_confidence: float = None, + appearance_frequency: float = None, + roleid: int = None, + faceid: int = None, + **kwargs, + ) -> None: + self.name = name + self.age = age + self.gender = gender + self.gender_confidence = gender_confidence + self.appearance_frequency = appearance_frequency + self.roleid = roleid + self.faceid = faceid + self.__dict__.update(**kwargs) + + @classmethod + def from_data(cls, data, **kwargs): + return Role(**data, **kwargs) + + +class Roles(Items): + def __init__(self, data: List[Role] = None, **kwargs): + super().__init__(data) + self.roles = self.data + self.__dict__.update(**kwargs) + + @classmethod + def from_data(cls, datas: List, role_kwargs=None, **kwargs) -> Roles: + if role_kwargs is None: + role_kwargs = {} + roles = [Role.from_data(role, **role_kwargs) for role in datas] + return Roles(roles, **kwargs) diff --git a/MuseV/MMCM/mmcm/vision/vis/__init__.py b/MuseV/MMCM/mmcm/vision/vis/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..4360dc37f4496a5d3ba0a8cf374337a999da9e68 --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/vis/__init__.py @@ -0,0 +1 @@ +from .vis_video_map import vis_video_map diff --git a/MuseV/MMCM/mmcm/vision/vis/vis_video_map.py b/MuseV/MMCM/mmcm/vision/vis/vis_video_map.py new file mode 100755 index 0000000000000000000000000000000000000000..9ed8bc5256e67b2338aff9d1e91b84babe26419e --- /dev/null +++ b/MuseV/MMCM/mmcm/vision/vis/vis_video_map.py @@ -0,0 +1,68 @@ +# -*- encoding: utf-8 -*- +import sys +import json + +import cv2 +from moviepy.editor import VideoFileClip + + +def vis_video_map(video_path, video_map, save_path): + from yolov5.utils.plots import Annotator, colors + if isinstance(video_map, str): + video_map = json.load(open(video_map, encoding="UTF-8")) + face_detections = [] + for i in video_map["face_detections"]: + if i["faces"] and len(i["faces"]) > 0: + face_detections.append(i) + video_path = video_map["video_path"] + # Capture video + video = VideoFileClip(video_path) + video = video.crop(*video_map["content_box"]) + fps = video.fps + duration = video.duration + width, height = video.size + print("fps, duration, width, height:", fps, duration, width, height) + vid_writer = cv2.VideoWriter( + save_path, + cv2.VideoWriter_fourcc(*"mp4v"), + video_map["detect_fps"], + (width, height), + ) + frame_idx = 0 + face_idx = 0 + for im in video.iter_frames(fps=video_map["sample_fps"]): + if face_idx == len(face_detections): + break + if frame_idx == 50000: + break + if frame_idx == face_detections[face_idx]["frame_idx"]: + print(frame_idx) + pred = face_detections[face_idx]["faces"] + im = cv2.cvtColor(im, cv2.COLOR_RGB2BGR) + annotator = Annotator(im, line_width=2, pil=not ascii) + if pred is not None and len(pred): + for p in pred: + conf = float(p["det_score"]) + bboxes = p["bbox"] + track_id = p["trackid"] + c_gender = float(p["gender"]) + c_age = p["age"] + if "roleid" in p: + roleid = p["roleid"] + if roleid >= 20: + continue + role = video_map["role_info"]["leading_roles"][roleid] + role_gender = role["gender_confidence"] + role_age = role["age"] + label = f"{track_id} {c_gender:.3f} {c_age} {conf:.2f} {roleid} {role_gender} {role_age}" + # label = f'{track_id} {c_gender:.3f} {c_age} {conf:.2f} {roleid}' + else: + label = f"{track_id} {c_gender:.3f} {c_age} {conf:.2f}" + annotator.box_label(bboxes, label, color=colors(0, True)) + else: + print("No detections") + # Stream results + im0 = annotator.result() + vid_writer.write(im0) + face_idx += 1 + frame_idx += 1 diff --git a/MuseV/MMCM/requirements.txt b/MuseV/MMCM/requirements.txt new file mode 100755 index 0000000000000000000000000000000000000000..6de072983fe5b6ba057c735a821f0e76e95f40a9 --- /dev/null +++ b/MuseV/MMCM/requirements.txt @@ -0,0 +1,99 @@ + +# tensorflow==2.12.0 +# tensorboard==2.12.0 + +# torch==2.0.1+cu118 +# torchvision==0.15.2+cu118 +torch==2.0.1 --index-url https://download.pytorch.org/whl/cu118 +torchvision==0.15.2 --index-url https://download.pytorch.org/whl/cu118 +torchaudio==2.0.2 --index-url https://download.pytorch.org/whl/cu118 +ninja==1.11.1 +transformers==4.33.1 +bitsandbytes==0.41.1 +decord==0.6.0 +accelerate==0.22.0 +xformers==0.0.21 +omegaconf +einops +imageio==2.31.1 +pandas +h5py +matplotlib +modelcards==0.1.6 +pynvml==11.5.0 +black +pytest +moviepy==1.0.3 +torch-tb-profiler==0.4.1 +scikit-learn +librosa +ffmpeg +easydict +webp +mediapipe==0.10.3 +cython==3.0.2 +easydict +gdown +infomap==2.7.1 +insightface==0.7.3 +ipython +librosa==0.10.1 +onnx==1.14.1 +onnxruntime==1.15.1 +onnxsim==0.4.33 +opencv_python +Pillow +protobuf==3.20.3 +pytube==15.0.0 +PyYAML +requests +scipy +six +tqdm +gradio +albumentations==1.3.1 +opencv-contrib-python==4.8.0.76 +imageio-ffmpeg==0.4.8 +pytorch-lightning==2.0.8 +test-tube==0.7.5 +timm==0.9.12 +addict +yapf +prettytable +safetensors==0.3.3 +fvcore +pycocotools +wandb==0.15.10 +wget +ffmpeg-python +streamlit +webdataset +kornia==0.7.0 +open_clip_torch==2.20.0 +streamlit-drawable-canvas==0.9.3 +torchmetrics==1.1.1 +invisible-watermark==0.1.5 +gdown==4.5.3 +ftfy==6.1.1 +modelcards==0.1.6 +jupyters +ipywidgets==8.0.3 +ipython +matplotlib==3.6.2 +redis==4.5.1 +pydantic[dotenv]==1.10.2 +loguru==0.6.0 +IProgress==0.4 +markupsafe==2.0.1 +xlsxwriter +cuid +spaces +# if need controlnet_aux depth, install this +basicsr==1.4.2 +https://mirrors.cloud.tencent.com/pypi/packages/de/a6/a49d5af79a515f5c9552a26b2078d839c40fcf8dccc0d94a1269276ab181/tb_nightly-2.1.0a20191022-py3-none-any.whl + +git+https://github.com/tencent-ailab/IP-Adapter.git@main +git+https://github.com/openai/CLIP.git@main + +git+https://github.com/TMElyralab/controlnet_aux.git@tme +git+https://github.com/TMElyralab/diffusers.git@tme \ No newline at end of file diff --git a/MuseV/MMCM/setup.py b/MuseV/MMCM/setup.py new file mode 100755 index 0000000000000000000000000000000000000000..9df72a885c060ac76d501e00e8f6bf15c7cac72a --- /dev/null +++ b/MuseV/MMCM/setup.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python + +from setuptools import setup, find_packages + +with open("README.md", "r") as fh: + long_description = fh.read() + +setup( + name="mmcm", # used in pip install + version="1.0.0", + author="anchorxia", + author_email="anchorxia@tencent.com", + description="process package for multi media cross modal", + # long_description=long_description, + # long_description_content_type="text/markdown", + url="https://github.com/TMElyralab/MMCM", + # include_package_data=True, # please edit MANIFEST.in + packages=find_packages(), # used in import + classifiers=[ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + ], + install_requires=[], +) diff --git a/app_gradio_space.py b/app_gradio_space.py index ccafaee1b1a27a26ff1a6ce585cdf122b1084ae6..06ebf11f98f75cbe6ecab6e552b0c16819e58f53 100644 --- a/app_gradio_space.py +++ b/app_gradio_space.py @@ -21,6 +21,7 @@ max_image_edge = 960 sys.path.insert(0, f"{ProjectDir}") sys.path.insert(0, f"{ProjectDir}/MMCM") sys.path.insert(0, f"{ProjectDir}/scripts/gradio") +print("sys.path", sys.path) result = subprocess.run( ["pip", "install", "--no-cache-dir", "-U", "openmim"],